Javasci: nio.buffer can be used with double, integer and boolean data 10/11510/4
Calixte DENIZET [Wed, 15 May 2013 12:58:23 +0000 (14:58 +0200)]
Change-Id: Ib9d79da8848161135996e7e1e1c934b3a38b353e

32 files changed:
scilab/modules/javasci/src/java/org/scilab/modules/javasci/Scilab.java
scilab/modules/javasci/src/java/org/scilab/modules/javasci/ScilabVariablesJavasci.java
scilab/modules/javasci/tests/java/org/scilab/tests/modules/javasci/testReadWrite.java
scilab/modules/javasci/tests/java/org/scilab/tests/modules/javasci/testReadWriteBuf.java [new file with mode: 0644]
scilab/modules/types/includes/GetScilabVariable.h
scilab/modules/types/includes/ScilabToJava.hxx
scilab/modules/types/src/cpp/ScilabToJava.cpp
scilab/modules/types/src/java/org/scilab/modules/types/GetScilabVariable.java
scilab/modules/types/src/java/org/scilab/modules/types/GetScilabVariableJNI.java
scilab/modules/types/src/java/org/scilab/modules/types/ScilabBoolean.java
scilab/modules/types/src/java/org/scilab/modules/types/ScilabBooleanReference.java [new file with mode: 0644]
scilab/modules/types/src/java/org/scilab/modules/types/ScilabBooleanSparse.java
scilab/modules/types/src/java/org/scilab/modules/types/ScilabDouble.java
scilab/modules/types/src/java/org/scilab/modules/types/ScilabDoubleReference.java [new file with mode: 0644]
scilab/modules/types/src/java/org/scilab/modules/types/ScilabInteger.java
scilab/modules/types/src/java/org/scilab/modules/types/ScilabIntegerReference.java [new file with mode: 0644]
scilab/modules/types/src/java/org/scilab/modules/types/ScilabList.java
scilab/modules/types/src/java/org/scilab/modules/types/ScilabMList.java
scilab/modules/types/src/java/org/scilab/modules/types/ScilabPolynomial.java
scilab/modules/types/src/java/org/scilab/modules/types/ScilabSparse.java
scilab/modules/types/src/java/org/scilab/modules/types/ScilabString.java
scilab/modules/types/src/java/org/scilab/modules/types/ScilabTList.java
scilab/modules/types/src/java/org/scilab/modules/types/ScilabType.java
scilab/modules/types/src/java/org/scilab/modules/types/ScilabTypeUtils.java [new file with mode: 0644]
scilab/modules/types/src/java/org/scilab/modules/types/ScilabVariables.java
scilab/modules/types/src/jni/ScilabVariables.cpp
scilab/modules/types/src/jni/ScilabVariables.giws.xml
scilab/modules/types/src/jni/ScilabVariables.hxx
scilab/modules/types/src/jni/ScilabVariablesRefresh.cpp
scilab/modules/types/src/jni/ScilabVariablesRefresh.hxx
scilab/modules/types/src/jni/getScilabVariable.i
scilab/modules/types/src/jni/getScilabVariable_wrap.c

index 452fc00..58aa20f 100644 (file)
@@ -168,19 +168,19 @@ public class Scilab {
     public boolean open() throws JavasciException {
         int res = Call_Scilab.Call_ScilabOpen(this.SCI, this.advancedMode, null, -1);
         switch (res) {
-        case 0: /* Success */
-            return true;
-        case -1:
-            throw new AlreadyRunningException("Javasci already running.");
-        case -2:
-            /* Should not occurd (processed before) */
-            throw new InitializationException("Could not find SCI.");
-        case -3:
-            throw new InitializationException("No existing directory.");
-        case 10001:
-            throw new InitializationException("Stacksize failed (not enought memory ?).");
-        default:
-            throw new InitializationException("Unknown startup error: " + res);
+            case 0: /* Success */
+                return true;
+            case -1:
+                throw new AlreadyRunningException("Javasci already running.");
+            case -2:
+                /* Should not occurd (processed before) */
+                throw new InitializationException("Could not find SCI.");
+            case -3:
+                throw new InitializationException("No existing directory.");
+            case 10001:
+                throw new InitializationException("Stacksize failed (not enought memory ?).");
+            default:
+                throw new InitializationException("Unknown startup error: " + res);
         }
     }
 
@@ -543,6 +543,27 @@ public class Scilab {
     }
 
     /**
+     * Returns a reference variable named varname<br />
+     * Throws an exception if the datatype is not managed or if the variable is not available
+     * <br />
+     * Example:<br />
+     * <code>
+     * double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};<br />
+     * double [][]aImg={{212.2, 221.0, 423.0, 393.0},{234.2, 244.0, 441.0, 407.0}};<br />
+     * ScilabDouble aOriginal = new ScilabDouble(a, aImg);<br />
+     * sci.put("a",aOriginal);<br />
+     * ScilabDouble aFromScilab = (ScilabDouble)sci.get("a");<br />
+     * <br />
+     * </code>
+     * @param varname the name of the variable
+     * @return return the variable
+     * @throws UnsupportedTypeException Type not managed yet.
+     */
+    public ScilabType getByReference(String varname) throws JavasciException {
+        return getInCurrentScilabSession(varname, true);
+    }
+
+    /**
      * Returns a variable named varname in the current Scilab session<br />
      * Throws an exception if the datatype is not managed or if the variable is not available
      * <br />
@@ -560,39 +581,60 @@ public class Scilab {
      * @throws UnsupportedTypeException Type not managed yet.
      */
     public static ScilabType getInCurrentScilabSession(String varname) throws JavasciException {
+        return getInCurrentScilabSession(varname, false);
+    }
+
+    /**
+     * Returns a variable named varname in the current Scilab session<br />
+     * Throws an exception if the datatype is not managed or if the variable is not available
+     * <br />
+     * Example:<br />
+     * <code>
+     * double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};<br />
+     * double [][]aImg={{212.2, 221.0, 423.0, 393.0},{234.2, 244.0, 441.0, 407.0}};<br />
+     * ScilabDouble aOriginal = new ScilabDouble(a, aImg);<br />
+     * sci.put("a",aOriginal);<br />
+     * ScilabDouble aFromScilab = (ScilabDouble)sci.get("a");<br />
+     * <br />
+     * </code>
+     * @param varname the name of the variable
+     * @return return the variable
+     * @throws UnsupportedTypeException Type not managed yet.
+     */
+    public static ScilabType getInCurrentScilabSession(String varname, boolean byref) throws JavasciException {
         ScilabTypeEnum sciType = getVariableTypeInCurrentScilabSession(varname);
         switch (sciType) {
-        case sci_matrix:
-        case sci_boolean:
-        case sci_strings:
-
-        case sci_poly:
-        case sci_sparse:
-        case sci_boolean_sparse:
-        case sci_list:
-        case sci_tlist:
-        case sci_mlist:
-            return ScilabVariablesJavasci.getScilabVariable(varname);
-        case sci_ints:
-            ScilabIntegerTypeEnum typeInt = Call_Scilab.getIntegerPrecision(varname);
-
-            switch (typeInt) {
-            case sci_int8:
-            case sci_uint8:
-            case sci_int16:
-            case sci_uint16:
-            case sci_int32:
-            case sci_uint32:
-                return ScilabVariablesJavasci.getScilabVariable(varname);
-            case sci_int64:
-            case sci_uint64:
-                // will be available in Scilab 6
-                throw new UnsupportedTypeException("64 bit (signed and unsigned) integer types not managed in Scilab 5.X");
+            case sci_matrix:
+            case sci_boolean:
+            case sci_strings:
+
+            case sci_poly:
+            case sci_sparse:
+            case sci_boolean_sparse:
+            case sci_list:
+            case sci_tlist:
+            case sci_mlist:
+                return ScilabVariablesJavasci.getScilabVariable(varname, true, byref);
+            case sci_ints:
+                ScilabIntegerTypeEnum typeInt = Call_Scilab.getIntegerPrecision(varname);
+
+                switch (typeInt) {
+                    case sci_int8:
+                    case sci_uint8:
+                    case sci_int16:
+                    case sci_uint16:
+                    case sci_int32:
+                    case sci_uint32:
+                        return ScilabVariablesJavasci.getScilabVariable(varname, true, byref);
+                    case sci_int64:
+                    case sci_uint64:
+                        // will be available in Scilab 6
+                        throw new UnsupportedTypeException("64 bit (signed and unsigned) integer types not managed in Scilab 5.X");
 
-            }
+                }
 
-        default:
-            throw new UnsupportedTypeException("Type not managed: " + sciType);
+            default:
+                throw new UnsupportedTypeException("Type not managed: " + sciType);
         }
     }
 
@@ -638,82 +680,82 @@ public class Scilab {
         int err = notHandledError; /* -999: if the type is not handled */
 
         switch (theVariable.getType()) {
-        case sci_matrix :
-            ScilabDouble sciDouble = (ScilabDouble) theVariable;
-            if (sciDouble.isReal()) {
-                err = Call_Scilab.putDouble(varname, sciDouble.getRealPart());
-            } else {
-                err = Call_Scilab.putDoubleComplex(varname, sciDouble.getRealPart(), sciDouble.getImaginaryPart());
-            }
-            break;
-        case sci_poly :
-            ScilabPolynomial sciPoly = (ScilabPolynomial) theVariable;
-            if (sciPoly.isReal()) {
-                err = Call_Scilab.putPolynomial(varname, sciPoly.getPolyVarName(), sciPoly.getRealPart());
-            } else {
-                err = Call_Scilab.putComplexPolynomial(varname, sciPoly.getPolyVarName(), sciPoly.getRealPart(), sciPoly.getImaginaryPart());
-            }
-            break;
-        case sci_boolean :
-            ScilabBoolean sciBoolean = (ScilabBoolean) theVariable;
-            err = Call_Scilab.putBoolean(varname, sciBoolean.getData());
-            break;
-        case sci_sparse :
-            ScilabSparse sciSparse = (ScilabSparse) theVariable;
-            if (sciSparse.isReal()) {
-                err = Call_Scilab.putSparse(varname, sciSparse.getHeight(), sciSparse.getWidth(), sciSparse.getNbItemRow(), sciSparse.getScilabColPos(), sciSparse.getRealPart());
-            } else {
-                err = Call_Scilab.putComplexSparse(varname, sciSparse.getHeight(), sciSparse.getWidth(), sciSparse.getNbItemRow(), sciSparse.getScilabColPos(), sciSparse.getRealPart(), sciSparse.getImaginaryPart());
-            }
-            break;
-        case sci_boolean_sparse :
-            ScilabBooleanSparse sciBooleanSparse = (ScilabBooleanSparse) theVariable;
-            err = Call_Scilab.putBooleanSparse(varname, sciBooleanSparse.getHeight(), sciBooleanSparse.getWidth(), sciBooleanSparse.getNbItemRow(), sciBooleanSparse.getScilabColPos());
-            break;
-        case sci_ints :
-            ScilabInteger sciInteger = (ScilabInteger) theVariable;
-            switch (sciInteger.getPrec()) {
-            case sci_uint8:
-                err = Call_Scilab.putUnsignedByte(varname, sciInteger.getDataAsByte());
+            case sci_matrix :
+                ScilabDouble sciDouble = (ScilabDouble) theVariable;
+                if (sciDouble.isReal()) {
+                    err = Call_Scilab.putDouble(varname, sciDouble.getRealPart());
+                } else {
+                    err = Call_Scilab.putDoubleComplex(varname, sciDouble.getRealPart(), sciDouble.getImaginaryPart());
+                }
+                break;
+            case sci_poly :
+                ScilabPolynomial sciPoly = (ScilabPolynomial) theVariable;
+                if (sciPoly.isReal()) {
+                    err = Call_Scilab.putPolynomial(varname, sciPoly.getPolyVarName(), sciPoly.getRealPart());
+                } else {
+                    err = Call_Scilab.putComplexPolynomial(varname, sciPoly.getPolyVarName(), sciPoly.getRealPart(), sciPoly.getImaginaryPart());
+                }
+                break;
+            case sci_boolean :
+                ScilabBoolean sciBoolean = (ScilabBoolean) theVariable;
+                err = Call_Scilab.putBoolean(varname, sciBoolean.getData());
+                break;
+            case sci_sparse :
+                ScilabSparse sciSparse = (ScilabSparse) theVariable;
+                if (sciSparse.isReal()) {
+                    err = Call_Scilab.putSparse(varname, sciSparse.getHeight(), sciSparse.getWidth(), sciSparse.getNbItemRow(), sciSparse.getScilabColPos(), sciSparse.getRealPart());
+                } else {
+                    err = Call_Scilab.putComplexSparse(varname, sciSparse.getHeight(), sciSparse.getWidth(), sciSparse.getNbItemRow(), sciSparse.getScilabColPos(), sciSparse.getRealPart(), sciSparse.getImaginaryPart());
+                }
                 break;
-            case sci_int8:
-                err = Call_Scilab.putByte(varname, sciInteger.getDataAsByte());
+            case sci_boolean_sparse :
+                ScilabBooleanSparse sciBooleanSparse = (ScilabBooleanSparse) theVariable;
+                err = Call_Scilab.putBooleanSparse(varname, sciBooleanSparse.getHeight(), sciBooleanSparse.getWidth(), sciBooleanSparse.getNbItemRow(), sciBooleanSparse.getScilabColPos());
                 break;
-            case sci_uint16:
-                err = Call_Scilab.putUnsignedShort(varname, sciInteger.getDataAsShort());
+            case sci_ints :
+                ScilabInteger sciInteger = (ScilabInteger) theVariable;
+                switch (sciInteger.getPrec()) {
+                    case sci_uint8:
+                        err = Call_Scilab.putUnsignedByte(varname, sciInteger.getDataAsByte());
+                        break;
+                    case sci_int8:
+                        err = Call_Scilab.putByte(varname, sciInteger.getDataAsByte());
+                        break;
+                    case sci_uint16:
+                        err = Call_Scilab.putUnsignedShort(varname, sciInteger.getDataAsShort());
+                        break;
+                    case sci_int16:
+                        err = Call_Scilab.putShort(varname, sciInteger.getDataAsShort());
+                        break;
+                    case sci_uint32:
+                        err = Call_Scilab.putUnsignedInt(varname, sciInteger.getDataAsInt());
+                        break;
+                    case sci_int32:
+                        err = Call_Scilab.putInt(varname, sciInteger.getDataAsInt());
+                        break;
+                    case sci_uint64:
+                        //                    err = Call_Scilab.putUnsignedLong(varname, sciInteger.getData_());
+                    case sci_int64:
+                        //                    err = Call_Scilab.putLong(varname, sciInteger.getData_());
+                        break;
+                }
                 break;
-            case sci_int16:
-                err = Call_Scilab.putShort(varname, sciInteger.getDataAsShort());
+            case sci_strings :
+                ScilabString sciString = (ScilabString) theVariable;
+                err = Call_Scilab.putString(varname, sciString.getData());
                 break;
-            case sci_uint32:
-                err = Call_Scilab.putUnsignedInt(varname, sciInteger.getDataAsInt());
+            case sci_list :
+                ScilabList sciList = (ScilabList) theVariable;
+                err = Call_ScilabJNI.putList(varname, sciList.getSerializedObject(), 'l');
                 break;
-            case sci_int32:
-                err = Call_Scilab.putInt(varname, sciInteger.getDataAsInt());
+            case sci_tlist :
+                ScilabTList sciTList = (ScilabTList) theVariable;
+                err = Call_ScilabJNI.putList(varname, sciTList.getSerializedObject(), 't');
                 break;
-            case sci_uint64:
-                //                    err = Call_Scilab.putUnsignedLong(varname, sciInteger.getData_());
-            case sci_int64:
-                //                    err = Call_Scilab.putLong(varname, sciInteger.getData_());
+            case sci_mlist :
+                ScilabMList sciMList = (ScilabMList) theVariable;
+                err = Call_ScilabJNI.putList(varname, sciMList.getSerializedObject(), 'm');
                 break;
-            }
-            break;
-        case sci_strings :
-            ScilabString sciString = (ScilabString) theVariable;
-            err = Call_Scilab.putString(varname, sciString.getData());
-            break;
-        case sci_list :
-            ScilabList sciList = (ScilabList) theVariable;
-            err = Call_ScilabJNI.putList(varname, sciList.getSerializedObject(), 'l');
-            break;
-        case sci_tlist :
-            ScilabTList sciTList = (ScilabTList) theVariable;
-            err = Call_ScilabJNI.putList(varname, sciTList.getSerializedObject(), 't');
-            break;
-        case sci_mlist :
-            ScilabMList sciMList = (ScilabMList) theVariable;
-            err = Call_ScilabJNI.putList(varname, sciMList.getSerializedObject(), 'm');
-            break;
         }
 
         if (err == notHandledError) {
index 634db63..933457e 100644 (file)
@@ -45,15 +45,20 @@ public final class ScilabVariablesJavasci implements ScilabVariablesHandler {
      * Get a Scilab variable with a given name
      * @param name the variable name
      * @param swapRowCol if true the returned data will be stored row by row
+     * @param byref if true the variable is passed by reference if it is possible
      * @return the corresponding ScilabType object
      */
-    public static final ScilabType getScilabVariable(String name, boolean swapRowCol) {
+    public static final ScilabType getScilabVariable(String name, boolean swapRowCol, boolean byref) {
         if (id == -1) {
             id = ScilabVariables.addScilabVariablesHandler(new ScilabVariablesJavasci());
         }
 
         if (name != null && !name.isEmpty()) {
-            GetScilabVariable.getScilabVariable(name, swapRowCol ? 1 : 0, id);
+            if (byref) {
+                GetScilabVariable.getScilabVariableAsReference(name, id);
+            } else {
+                GetScilabVariable.getScilabVariable(name, swapRowCol ? 1 : 0, id);
+            }
             Thread t = Thread.currentThread();
             ScilabType var = map.get(t);
             map.remove(t);
@@ -67,6 +72,16 @@ public final class ScilabVariablesJavasci implements ScilabVariablesHandler {
     /**
      * Get a Scilab variable with a given name
      * @param name the variable name
+     * @param swapRowCol if true the returned data will be stored row by row
+     * @return the corresponding ScilabType object
+     */
+    public static final ScilabType getScilabVariable(String name, boolean swapRowCol) {
+        return getScilabVariable(name, swapRowCol, false);
+    }
+
+    /**
+     * Get a Scilab variable with a given name
+     * @param name the variable name
      * @return the corresponding ScilabType object where the data are stored row by row
      */
     public static final ScilabType getScilabVariable(String name) {
index 918e7ee..3a3abd1 100644 (file)
@@ -60,6 +60,7 @@ public class testReadWrite {
         assertTrue(aFromScilab.equals(aOriginal));
     }
 
+    @Test()
     public void putAndGetDoubleTest() throws NullPointerException, JavasciException {
         double [][]a = {{21.2, 22.0, 42.0, 39.0}, {23.2, 24.0, 44.0, 40.0}};
         ScilabDouble aOriginal = new ScilabDouble(a);
diff --git a/scilab/modules/javasci/tests/java/org/scilab/tests/modules/javasci/testReadWriteBuf.java b/scilab/modules/javasci/tests/java/org/scilab/tests/modules/javasci/testReadWriteBuf.java
new file mode 100644 (file)
index 0000000..0bca3c5
--- /dev/null
@@ -0,0 +1,207 @@
+/*
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2010 - DIGITEO - Sylvestre LEDRU
+ *
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ */
+package org.scilab.tests.modules.javasci;
+
+import org.junit.*;
+import static org.junit.Assert.*;
+
+import java.util.Arrays;
+import java.util.Map;
+
+import org.scilab.modules.javasci.Scilab;
+import org.scilab.modules.javasci.JavasciException;
+import org.scilab.modules.javasci.JavasciException.InitializationException;
+import org.scilab.modules.javasci.JavasciException.UnsupportedTypeException;
+import org.scilab.modules.javasci.JavasciException.UndefinedVariableException;
+import org.scilab.modules.types.ScilabType;
+import org.scilab.modules.types.ScilabDouble;
+import org.scilab.modules.types.ScilabBoolean;
+import org.scilab.modules.types.ScilabBooleanSparse;
+import org.scilab.modules.types.ScilabInteger;
+import org.scilab.modules.types.ScilabMList;
+import org.scilab.modules.types.ScilabList;
+import org.scilab.modules.types.ScilabTList;
+import org.scilab.modules.types.ScilabPolynomial;
+import org.scilab.modules.types.ScilabString;
+import org.scilab.modules.types.ScilabSparse;
+import org.scilab.modules.types.ScilabTypeEnum;
+
+public class testReadWriteBuf {
+    private Scilab sci;
+
+    /*
+     * This method will be called for each test.
+     * with @After, this ensures that all the time the engine is closed
+     * especially in case of error.
+     * Otherwise, the engine might be still running and all subsequent tests
+     * would fail.
+     */
+    @Before
+    public void open() throws NullPointerException, JavasciException {
+        sci = new Scilab();
+        assertTrue(sci.open());
+    }
+
+    @Test()
+    public void putAndGetRefDoubleTest() throws NullPointerException, JavasciException {
+        double [][]a = {{21.2, 22.0, 42.0, 39.0}, {23.2, 24.0, 44.0, 40.0}};
+        ScilabDouble aOriginal = new ScilabDouble(a);
+        sci.put("a", aOriginal);
+
+        ScilabDouble aFromScilab = (ScilabDouble)sci.getByReference("a");
+        assertTrue(aFromScilab.equals(aOriginal));
+        assertTrue(sci.exec("a(2,3)=12345;"));
+        assertTrue(aFromScilab.getRealElement(1, 2) == 12345);
+        aFromScilab.setRealElement(1, 2, 3.14159);
+        assertTrue(sci.exec("b=a(2,3);"));
+        ScilabDouble bFromScilab = (ScilabDouble)sci.get("b");
+        assertTrue(bFromScilab.equals(new ScilabDouble(3.14159)));
+    }
+
+    @Test()
+    public void putAndGetRefComplexDoubleTest() throws NullPointerException, JavasciException {
+        double [][]a = {{21.2, 22.0, 42.0, 39.0}, {23.2, 24.0, 44.0, 40.0}};
+        double [][]aImg = {{212.2, 221.0, 423.0, 393.0}, {234.2, 244.0, 441.0, 407.0}};
+        ScilabDouble aOriginal = new ScilabDouble(a, aImg);
+        sci.put("a", aOriginal);
+
+        ScilabDouble aFromScilab = (ScilabDouble)sci.getByReference("a");
+        assertTrue(aFromScilab.equals(aOriginal));
+        assertTrue(sci.exec("a(2,3)=12345+%i*5.4321;"));
+        assertTrue(aFromScilab.getRealElement(1, 2) == 12345 && aFromScilab.getImaginaryElement(1, 2) == 5.4321);
+        aFromScilab.setRealElement(1, 2, 3.14159);
+        aFromScilab.setImaginaryElement(1, 2, 2.71828);
+        assertTrue(sci.exec("b=a(2,3);"));
+        ScilabDouble bFromScilab = (ScilabDouble)sci.get("b");
+        assertTrue(bFromScilab.equals(new ScilabDouble(3.14159, 2.71828)));
+    }
+
+    @Test()
+    public void putAndGetRefInt8Test() throws NullPointerException, JavasciException {
+        byte[][] a = {{1, 2, 3, 4}, {5, 6, 7, 8}};
+        ScilabInteger aOriginal = new ScilabInteger(a, false);
+        sci.put("a", aOriginal);
+
+        ScilabInteger aFromScilab = (ScilabInteger)sci.getByReference("a");
+        assertTrue(aFromScilab.equals(aOriginal));
+        assertTrue(sci.exec("a(2,3)=123;"));
+        assertTrue(aFromScilab.getElement(1, 2) == 123);
+        aFromScilab.setElement(1, 2, (byte) - 98);
+        assertTrue(sci.exec("b=a(2,3);"));
+        ScilabInteger bFromScilab = (ScilabInteger)sci.get("b");
+        assertTrue(bFromScilab.equals(new ScilabInteger((byte) - 98, false)));
+    }
+
+    @Test()
+    public void putAndGetRefUInt8Test() throws NullPointerException, JavasciException {
+        byte[][] a = {{1, 2, 3, 4}, {5, 6, 7, 8}};
+        ScilabInteger aOriginal = new ScilabInteger(a, true);
+        sci.put("a", aOriginal);
+
+        ScilabInteger aFromScilab = (ScilabInteger)sci.getByReference("a");
+        assertTrue(aFromScilab.equals(aOriginal));
+        assertTrue(sci.exec("a(2,3)=253;"));
+        assertTrue(aFromScilab.getElement(1, 2) == (byte)253);
+        aFromScilab.setElement(1, 2, (byte)189);
+        assertTrue(sci.exec("b=a(2,3);"));
+        ScilabInteger bFromScilab = (ScilabInteger)sci.get("b");
+        assertTrue(bFromScilab.equals(new ScilabInteger((byte)189, true)));
+    }
+
+    @Test()
+    public void putAndGetRefInt16Test() throws NullPointerException, JavasciException {
+        short[][] a = {{1, 2, 3, 4}, {5, 6, 7, 8}};
+        ScilabInteger aOriginal = new ScilabInteger(a, false);
+        sci.put("a", aOriginal);
+
+        ScilabInteger aFromScilab = (ScilabInteger)sci.getByReference("a");
+        assertTrue(aFromScilab.equals(aOriginal));
+        assertTrue(sci.exec("a(2,3)=123;"));
+        assertTrue(aFromScilab.getElement(1, 2) == 123);
+        aFromScilab.setElement(1, 2, (short) - 98);
+        assertTrue(sci.exec("b=a(2,3);"));
+        ScilabInteger bFromScilab = (ScilabInteger)sci.get("b");
+        assertTrue(bFromScilab.equals(new ScilabInteger((short) - 98, false)));
+    }
+
+    @Test()
+    public void putAndGetRefUInt16Test() throws NullPointerException, JavasciException {
+        short[][] a = {{1, 2, 3, 4}, {5, 6, 7, 8}};
+        ScilabInteger aOriginal = new ScilabInteger(a, true);
+        sci.put("a", aOriginal);
+
+        ScilabInteger aFromScilab = (ScilabInteger)sci.getByReference("a");
+        assertTrue(aFromScilab.equals(aOriginal));
+        assertTrue(sci.exec("a(2,3)=253;"));
+        assertTrue(aFromScilab.getElement(1, 2) == (short)253);
+        aFromScilab.setElement(1, 2, (short)189);
+        assertTrue(sci.exec("b=a(2,3);"));
+        ScilabInteger bFromScilab = (ScilabInteger)sci.get("b");
+        assertTrue(bFromScilab.equals(new ScilabInteger((short)189, true)));
+    }
+
+    @Test()
+    public void putAndGetRefInt32Test() throws NullPointerException, JavasciException {
+        int[][] a = {{1, 2, 3, 4}, {5, 6, 7, 8}};
+        ScilabInteger aOriginal = new ScilabInteger(a, false);
+        sci.put("a", aOriginal);
+
+        ScilabInteger aFromScilab = (ScilabInteger)sci.getByReference("a");
+        assertTrue(aFromScilab.equals(aOriginal));
+        assertTrue(sci.exec("a(2,3)=123;"));
+        assertTrue(aFromScilab.getElement(1, 2) == 123);
+        aFromScilab.setElement(1, 2, (int) - 98);
+        assertTrue(sci.exec("b=a(2,3);"));
+        ScilabInteger bFromScilab = (ScilabInteger)sci.get("b");
+        assertTrue(bFromScilab.equals(new ScilabInteger((int) - 98, false)));
+    }
+
+    @Test()
+    public void putAndGetRefUInt32Test() throws NullPointerException, JavasciException {
+        int[][] a = {{1, 2, 3, 4}, {5, 6, 7, 8}};
+        ScilabInteger aOriginal = new ScilabInteger(a, true);
+        sci.put("a", aOriginal);
+
+        ScilabInteger aFromScilab = (ScilabInteger)sci.getByReference("a");
+        assertTrue(aFromScilab.equals(aOriginal));
+        assertTrue(sci.exec("a(2,3)=253;"));
+        assertTrue(aFromScilab.getElement(1, 2) == (int)253);
+        aFromScilab.setElement(1, 2, (int)189);
+        assertTrue(sci.exec("b=a(2,3);"));
+        ScilabInteger bFromScilab = (ScilabInteger)sci.get("b");
+        assertTrue(bFromScilab.equals(new ScilabInteger((int)189, true)));
+    }
+
+    @Test()
+    public void putAndGetRefBooleanTest() throws NullPointerException, JavasciException {
+        boolean[][] a = {{true, false, true, true}, {false, false, true, true}};
+        ScilabBoolean aOriginal = new ScilabBoolean(a);
+        sci.put("a", aOriginal);
+
+        ScilabBoolean aFromScilab = (ScilabBoolean)sci.getByReference("a");
+        assertTrue(aFromScilab.equals(aOriginal));
+        assertTrue(sci.exec("a(2,3)=%f;"));
+        assertTrue(aFromScilab.getElement(1, 2) == false);
+        aFromScilab.setElement(1, 2, true);
+        assertTrue(sci.exec("b=a(2,3);"));
+        ScilabBoolean bFromScilab = (ScilabBoolean)sci.get("b");
+        assertTrue(bFromScilab.equals(new ScilabBoolean(true)));
+    }
+
+    /**
+     * See #open()
+     */
+    @After
+    public void close() {
+        sci.close();
+    }
+}
index 7d8d0e4..9a3b969 100644 (file)
@@ -1,6 +1,7 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2011 - DIGITEO - Calixte DENIZET
+ * Copyright (C) 2013 - Scilab Enterprises - Calixte DENIZET
  *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
@@ -15,4 +16,6 @@
 
 void getScilabVariable(const char * scilabVarName, int swapRowCol, int handlerId);
 
+void getScilabVariableAsReference(const char * variableName, int handlerId);
+
 #endif
index 71880f8..57a2214 100644 (file)
@@ -33,304 +33,339 @@ using namespace org_scilab_modules_types;
 namespace org_modules_types
 {
 
+/**
+ * @file
+ * @author Calixte DENIZET <calixte.denizet@scilab.org>
+ *
+ * Class to send Scilab datas in Java environment
+ */
+class ScilabToJava
+{
+
+    static int refreshId;
+
+    /**
+     * Get the pointer on the indexes
+     * @param indexes a vector containing indexes
+     * @return the pointer
+     */
+    static int * getIndexesPointer(std::vector<int> & indexes);
+
+    /**
+     * Get a double dimension matrix from a one dimension one
+     * The result must be delete in using deleteMatrix
+     *
+     * @param T the data type
+     * @param row the row number
+     * @param col the col number
+     * @param data the data
+     * @param swaped true if the matrix is stored row by row
+     * @return the double dimension matrix
+     */
+    template<typename T>
+    static T ** getMatrix(int row, int col, T * data, bool swaped);
+
+    /**
+     * Get a double dimension matrix from a one dimension one
+     * The result must be delete in using deleteMatrix
+     * Each data element is casted from T to U
+     *
+     * @param T the in data type
+     * @param U the out data type
+     * @param row the row number
+     * @param col the col number
+     * @param data the data
+     * @param swaped true if the matrix is stored row by row
+     * @return the double dimension matrix
+     */
+    template<typename T, typename U>
+    static T ** getConvertedMatrix(int row, int col, U * data, bool swaped);
+
+    /**
+     * Convert a single row matrix into a double dimension one
+     *
+     * @param row the row number
+     * @param col the col number
+     * @return the double dimension matrix
+     */
+    template<typename T>
+    static T ** convertMatrix(int row, int col, T * data);
+
+    /**
+     * Delete a matrix previously created with getMatrix or getConvertedMatrix
+     * or convertMatrix
+     *
+     * @param T the in data type
+     * @param data the data
+     * @param swaped true if the matrix is stored row by row
+     */
+    template<typename T>
+    static void deleteMatrix(T ** data, bool swaped);
+
+    /**
+     * Send the list items
+     *
+     * @param name the variable name
+    * @param nbItems the number of items
+           * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
+           * @param addr the address of the variable in the Scilab stack
+           * @param swaped true if the matrix is stored row by row
+     * @param byref true if the variable is passed by reference
+           * @param handlerId the handler id
+           * @param pvApiCtx a pointer to the context
+           */
+    static bool sendItems(const std::string & name, const int nbItems, std::vector<int> & indexes, int * addr, bool swaped, bool byref, int handlerId, void * pvApiCtx);
+
+    /**
+     * Send a variable in the Java environment
+     *
+     * @param name the variable name
+     * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
+     * @param addr the address of the variable in the Scilab stack
+     * @param swaped true if the matrix is stored row by row
+    * @param byref true if the variable is passed by reference
+           * @param handlerId the handler id
+           * @param pvApiCtx a pointer to the context
+           */
+    static bool sendVariable(const std::string & name, std::vector<int> & indexes, int * addr, bool swaped, bool byref, int handlerId, void * pvApiCtx);
+
+    /**
+     * Send a list or a tlist or mlist in the Java environment
+     *
+     * @param name the variable name
+     * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
+     * @param type a char with the value 'l' or 'm' or 't'
+    * @param byref true if the variable is passed by reference
+           * @param handlerId the handler id
+           */
+    static void sendVariable(const std::string & name, const int nbItems, std::vector<int> & indexes, char type, bool byref, int handlerId);
+
+    /**
+     * Close a list or a tlist or mlist in the Java environment
+     *
+     * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
+     * @param handlerId the handler id
+     */
+    static void closeList(std::vector<int> & indexes, int handlerId);
+
+    /**
+     * Send double sparse matrix
+     *
+     * @param T the type of the data
+     * @param name the variable name
+     * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
+     * @param nbItem the number of non null elements
+     * @param nbItemRow the number by row of non null elements
+     * @param colPos the column position of the non null elements
+     * @param row the row number
+     * @param col the col number
+     * @param data the data
+    * @param byref true if the variable is passed by reference
+           * @param handlerId the handler id
+           */
+    template<typename T>
+    static void sendVariable(const std::string & name, std::vector<int> & indexes, int nbItem, int * nbItemRow, int * colPos, int row, int col, T * data, bool byref, int handlerId);
+
+    /**
+     * Send double, int* and uint64 matrices
+     *
+     * @param T the type of the data
+     * @param name the variable name
+     * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
+     * @param row the row number
+     * @param col the col number
+     * @param data the data
+     * @param swaped true if the matrix is stored row by row
+    * @param byref true if the variable is passed by reference
+           * @param handlerId the handler id
+           */
+    template<typename T>
+    static void sendVariable(const std::string & name, std::vector<int> & indexes, int row, int col, T * data, bool swaped, bool byref, int handlerId);
+
+    /**
+     * Send String matrices
+     *
+     * @param name the variable name
+     * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
+     * @param row the row number
+     * @param col the col number
+     * @param data the data
+     * @param swaped true if the matrix is stored row by row
+    * @param byref true if the variable is passed by reference
+           * @param handlerId the handler id
+           */
+    static void sendStringVariable(const std::string & name, std::vector<int> & indexes, int row, int col, char ** data, bool swaped, bool byref, int handlerId);
+
+    /**
+     * Send boolean sparse matrix
+     *
+     * @param name the variable name
+     * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
+     * @param nbItem the number of true elements
+     * @param nbItemRow the number by row of true elements
+     * @param colPos the column position of the true elements
+     * @param row the row number
+     * @param col the col number
+    * @param byref true if the variable is passed by reference
+           * @param handlerId the handler id
+           */
+    static void sendBooleanSparseVariable(const std::string & name, std::vector<int> & indexes, int nbItem, int * nbItemRow, int * colPos, int row, int col, bool byref, int handlerId);
+
+    /**
+     * Send uint* matrices (datas are converted to have the good Java type)
+     *
+     * @param T the type of the data
+     * @param U the type of the converted data
+     * @param name the variable name
+     * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
+     * @param row the row number
+     * @param col the col number
+     * @param data the data
+     * @param swaped true if the matrix is stored row by row
+     * @param handlerId the handler id
+     */
+    template<typename T, typename U>
+    static void sendUnsignedVariableWithCast(const std::string & name, std::vector<int> & indexes, int row, int col, U * data, bool swaped, int handlerId);
+
+    /**
+     * Send uint* matrices
+     *
+     * @param T the type of the data
+     * @param name the variable name
+     * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
+     * @param row the row number
+     * @param col the col number
+     * @param data the data
+     * @param swaped true if the matrix is stored row by row
+    * @param byref true if the variable is passed by reference
+           * @param handlerId the handler id
+           */
+    template<typename T>
+    static void sendUnsignedVariable(const std::string & name, std::vector<int> & indexes, int row, int col, T * data, bool swaped, bool byref, int handlerId);
+
+    /**
+     * Send boolean matrix (data are converted from int to bool)
+     *
+     * @param name the variable name
+     * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
+     * @param row the row number
+     * @param col the col number
+     * @param data the data
+     * @param swaped true if the matrix is stored row by row
+    * @param byref true if the variable is passed by reference
+           * @param handlerId the handler id
+           */
+    static void sendConvertedBooleanVariable(const std::string & name, std::vector<int> & indexes, int row, int col, int * data, bool swaped, bool byref, int handlerId);
+
+    /**
+     * Send complex sparse matrix
+     *
+     * @param T the type of the data
+     * @param name the variable name
+     * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
+     * @param nbItem the number of non null elements
+     * @param nbItemRow the number by row of non null elements
+     * @param colPos the column position of the non null elements
+     * @param row the row number
+     * @param col the col number
+     * @param real the real data
+     * @param img the imaginary data
+    * @param byref true if the variable is passed by reference
+           * @param handlerId the handler id
+           */
+    template<typename T>
+    static void sendVariable(const std::string & name, std::vector<int> & indexes, int nbItem, int * nbItemRow, int * colPos, int row, int col, T * real, T * img, bool byref, int handlerId);
+
+    /**
+     * Send complex matrices
+     *
+     * @param T the type of the data
+     * @param name the variable name
+     * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
+     * @param row the row number
+     * @param col the col number
+     * @param real the real data
+     * @param img the imaginary data
+     * @param swaped true if the matrix is stored row by row
+    * @param byref true if the variable is passed by reference
+           * @param handlerId the handler id
+           */
+    template<typename T>
+    static void sendVariable(const std::string & name, std::vector<int> & indexes, int row, int col, T * real, T * img, bool swaped, bool byref, int handlerId);
+
+    /**
+     * Send double polynomial matrices
+     *
+     * @param T the type of the data
+     * @param name the variable name
+     * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
+     * @param row the row number
+     * @param col the col number
+     * @param nbcoeff the number of coefficient of each polynomial
+     * @param data the data
+     * @param swaped true if the matrix is stored row by row
+    * @param byref true if the variable is passed by reference
+           * @param handlerId the handler id
+           */
+    template<typename T>
+    static void sendVariable(const std::string & name, std::vector<int> & indexes, const char * varName, int row, int col, int * nbcoeff, T ** data, bool swaped, bool byref, int handlerId);
+
+    /**
+     * Send complex polynomial matrices
+     *
+     * @param T the type of the data
+     * @param name the variable name
+     * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
+     * @param row the row number
+     * @param col the col number
+     * @param nbcoeff the number of coefficient of each polynomial
+     * @param real the real data
+     * @param img the imaginary data
+     * @param swaped true if the matrix is stored row by row
+    * @param byref true if the variable is passed by reference
+           * @param handlerId the handler id
+           */
+    template<typename T>
+    static void sendVariable(const std::string & name, std::vector<int> & indexes, const char * varName, int row, int col, int * nbcoeff, T ** real, T ** img, bool swaped, bool byref, int handlerId);
+
+public :
+
+    /**
+     * Send all the listened variables
+     */
+    static void sendAllListenedVariables();
+
+    /**
+     * Send a Scilab variable to the Java environment
+     *
+     * @param name the variable name
+     * @param swaped true if the matrix is stored row by row
+     * @param handlerId the handler id
+     * @return true if all was ok
+     */
+    static bool sendVariable(const std::string & name, bool swaped, int handlerId);
+
+    /**
+     * Send a Scilab variable to the Java environment as a reference when it is possible
+     *
+     * @param name the variable name
+     * @param handlerId the handler id
+     * @return true if all was ok
+     */
+    static bool sendVariableAsReference(const std::string & name, int handlerId);
+
     /**
-     * @file
-     * @author Calixte DENIZET <calixte.denizet@scilab.org>
+     * Send a Scilab variable to the Java environment
      *
-     * Class to send Scilab datas in Jav environment
+     * @param name the variable name
+     * @param addr the variable address in the Scilab stack
+     * @param swaped true if the matrix is stored row by row
+     * @param handlerId the handler id
+     * @param pvApiCtx a pointer to the context
+     * @return true if all was ok
      */
-    class ScilabToJava
-    {
-
-        static int refreshId;
-
-        /**
-         * Get the pointer on the indexes
-         * @param indexes a vector containing indexes
-         * @return the pointer
-         */
-        static int * getIndexesPointer(std::vector<int> & indexes);
-
-        /**
-         * Get a double dimension matrix from a one dimension one
-         * The result must be delete in using deleteMatrix
-         *
-         * @param T the data type
-         * @param row the row number
-         * @param col the col number
-         * @param data the data
-         * @param swaped true if the matrix is stored row by row
-         * @return the double dimension matrix
-         */
-        template<typename T>
-        static T ** getMatrix(int row, int col, T * data, bool swaped);
-
-        /**
-         * Get a double dimension matrix from a one dimension one
-         * The result must be delete in using deleteMatrix
-         * Each data element is casted from T to U
-         *
-         * @param T the in data type
-         * @param U the out data type
-         * @param row the row number
-         * @param col the col number
-         * @param data the data
-         * @param swaped true if the matrix is stored row by row
-         * @return the double dimension matrix
-         */
-        template<typename T, typename U>
-        static T ** getConvertedMatrix(int row, int col, U * data, bool swaped);
-
-        /**
-         * Convert a single row matrix into a double dimension one
-         *
-         * @param row the row number
-         * @param col the col number
-         * @return the double dimension matrix
-         */
-        template<typename T>
-        static T ** convertMatrix(int row, int col, T * data);
-
-        /**
-         * Delete a matrix previously created with getMatrix or getConvertedMatrix
-         * or convertMatrix
-         *
-         * @param T the in data type
-         * @param data the data
-         * @param swaped true if the matrix is stored row by row
-         */
-        template<typename T>
-        static void deleteMatrix(T ** data, bool swaped);
-
-        /**
-         * Send the list items
-         *
-         * @param name the variable name
-         * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
-         * @param addr the address of the variable in the Scilab stack
-         * @param swaped true if the matrix is stored row by row
-         * @param handlerId the handler id
-         * @param pvApiCtx a pointer to the context
-         */
-        static bool sendItems(const std::string & name, std::vector<int> & indexes, int * addr, bool swaped, int handlerId, void * pvApiCtx);
-
-        /**
-         * Send a variable in the Java environment
-         *
-         * @param name the variable name
-         * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
-         * @param addr the address of the variable in the Scilab stack
-         * @param swaped true if the matrix is stored row by row
-         * @param handlerId the handler id
-         * @param pvApiCtx a pointer to the context
-         */
-        static bool sendVariable(const std::string & name, std::vector<int> & indexes, int * addr, bool swaped, int handlerId, void * pvApiCtx);
-
-        /**
-         * Send a list or a tlist or mlist in the Java environment
-         *
-         * @param name the variable name
-         * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
-         * @param type a char with the value 'l' or 'm' or 't'
-         * @param handlerId the handler id
-         */
-        static void sendVariable(const std::string & name, std::vector<int> & indexes, char type, int handlerId);
-
-        /**
-         * Close a list or a tlist or mlist in the Java environment
-         *
-         * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
-         * @param handlerId the handler id
-         */
-        static void closeList(std::vector<int> & indexes, int handlerId);
-
-        /**
-         * Send double sparse matrix
-         *
-         * @param T the type of the data
-         * @param name the variable name
-         * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
-         * @param nbItem the number of non null elements
-         * @param nbItemRow the number by row of non null elements
-         * @param colPos the column position of the non null elements
-         * @param row the row number
-         * @param col the col number
-         * @param data the data
-         * @param handlerId the handler id
-         */
-        template<typename T>
-        static void sendVariable(const std::string & name, std::vector<int> & indexes, int nbItem, int * nbItemRow, int * colPos, int row, int col, T * data, int handlerId);
-
-        /**
-         * Send double, string, int* and uint64 matrices
-         *
-         * @param T the type of the data
-         * @param name the variable name
-         * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
-         * @param row the row number
-         * @param col the col number
-         * @param data the data
-         * @param swaped true if the matrix is stored row by row
-         * @param handlerId the handler id
-         */
-        template<typename T>
-        static void sendVariable(const std::string & name, std::vector<int> & indexes, int row, int col, T * data, bool swaped, int handlerId);
-
-        /**
-         * Send boolean sparse matrix
-         *
-         * @param name the variable name
-         * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
-         * @param nbItem the number of true elements
-         * @param nbItemRow the number by row of true elements
-         * @param colPos the column position of the true elements
-         * @param row the row number
-         * @param col the col number
-         * @param handlerId the handler id
-         */
-        static void sendBooleanSparseVariable(const std::string & name, std::vector<int> & indexes, int nbItem, int * nbItemRow, int * colPos, int row, int col, int handlerId);
-
-        /**
-         * Send uint* matrices (datas are converted to have the good Java type)
-         *
-         * @param T the type of the data
-         * @param U the type of the converted data
-         * @param name the variable name
-         * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
-         * @param row the row number
-         * @param col the col number
-         * @param data the data
-         * @param swaped true if the matrix is stored row by row
-         * @param handlerId the handler id
-         */
-        template<typename T, typename U>
-        static void sendUnsignedVariableWithCast(const std::string & name, std::vector<int> & indexes, int row, int col, U * data, bool swaped, int handlerId);
-
-        /**
-         * Send uint* matrices
-         *
-         * @param T the type of the data
-         * @param name the variable name
-         * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
-         * @param row the row number
-         * @param col the col number
-         * @param data the data
-         * @param swaped true if the matrix is stored row by row
-         * @param handlerId the handler id
-         */
-        template<typename T>
-        static void sendUnsignedVariable(const std::string & name, std::vector<int> & indexes, int row, int col, T * data, bool swaped, int handlerId);
-
-        /**
-         * Send boolean matrix (data are converted from int to bool)
-         *
-         * @param name the variable name
-         * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
-         * @param row the row number
-         * @param col the col number
-         * @param data the data
-         * @param swaped true if the matrix is stored row by row
-         * @param handlerId the handler id
-         */
-        static void sendConvertedBooleanVariable(const std::string & name, std::vector<int> & indexes, int row, int col, int * data, bool swaped, int handlerId);
-
-        /**
-         * Send complex sparse matrix
-         *
-         * @param T the type of the data
-         * @param name the variable name
-         * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
-         * @param nbItem the number of non null elements
-         * @param nbItemRow the number by row of non null elements
-         * @param colPos the column position of the non null elements
-         * @param row the row number
-         * @param col the col number
-         * @param real the real data
-         * @param img the imaginary data
-         * @param handlerId the handler id
-         */
-        template<typename T>
-        static void sendVariable(const std::string & name, std::vector<int> & indexes, int nbItem, int * nbItemRow, int * colPos, int row, int col, T * real, T * img, int handlerId);
-
-        /**
-         * Send complex matrices
-         *
-         * @param T the type of the data
-         * @param name the variable name
-         * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
-         * @param row the row number
-         * @param col the col number
-         * @param real the real data
-         * @param img the imaginary data
-         * @param swaped true if the matrix is stored row by row
-         * @param handlerId the handler id
-         */
-        template<typename T>
-        static void sendVariable(const std::string & name, std::vector<int> & indexes, int row, int col, T * real, T * img, bool swaped, int handlerId);
-
-        /**
-         * Send double polynomial matrices
-         *
-         * @param T the type of the data
-         * @param name the variable name
-         * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
-         * @param row the row number
-         * @param col the col number
-         * @param nbcoeff the number of coefficient of each polynomial
-         * @param data the data
-         * @param swaped true if the matrix is stored row by row
-         * @param handlerId the handler id
-         */
-        template<typename T>
-        static void sendVariable(const std::string & name, std::vector<int> & indexes, const char * varName, int row, int col, int * nbcoeff, T ** data, bool swaped, int handlerId);
-
-        /**
-         * Send complex polynomial matrices
-         *
-         * @param T the type of the data
-         * @param name the variable name
-         * @param indexes an integer array with the indexes of the (sub)*-list which will contain the data
-         * @param row the row number
-         * @param col the col number
-         * @param nbcoeff the number of coefficient of each polynomial
-         * @param real the real data
-         * @param img the imaginary data
-         * @param swaped true if the matrix is stored row by row
-         * @param handlerId the handler id
-         */
-        template<typename T>
-        static void sendVariable(const std::string & name, std::vector<int> & indexes, const char * varName, int row, int col, int * nbcoeff, T ** real, T ** img, bool swaped, int handlerId);
-
-    public :
-
-        /**
-         * Send all the listened variables
-         */
-        static void sendAllListenedVariables();
-
-        /**
-         * Send a Scilab variable to the Java environment
-         *
-         * @param name the variable name
-         * @param swaped true if the matrix is stored row by row
-         * @param handlerId the handler id
-         * @return true if all was ok
-         */
-        static bool sendVariable(const std::string & name, bool swaped, int handlerId);
-
-        /**
-         * Send a Scilab variable to the Java environment
-         *
-         * @param name the variable name
-         * @param addr the variable address in the Scilab stack
-         * @param swaped true if the matrix is stored row by row
-         * @param handlerId the handler id
-         * @param pvApiCtx a pointer to the context
-         * @return true if all was ok
-         */
-        static bool sendVariable(const std::string & name, int * addr, bool swaped, int handlerId, void * pvApiCtx);
-
-    };
+    static bool sendVariable(const std::string & name, int * addr, bool swaped, int handlerId, void * pvApiCtx);
+};
 }
 
 #endif
index 736023e..bdbe1bb 100644 (file)
@@ -1,6 +1,7 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2011 - DIGITEO - Calixte DENIZET
+ * Copyright (C) 2013 - Scilab Enterprises - Calixte DENIZET
  *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
 namespace org_modules_types
 {
 
-    int ScilabToJava::refreshId = -1;
+int ScilabToJava::refreshId = -1;
 
-    void ScilabToJava::sendAllListenedVariables()
+void ScilabToJava::sendAllListenedVariables()
+{
+    if (refreshId == -1)
     {
-        if (refreshId == -1)
-        {
-            refreshId = ScilabVariablesRefresh::getScilabVariablesRefreshId(getScilabJavaVM());
-        }
-
-        char ** vars = ScilabVariables::getAllListenedVariables(getScilabJavaVM());
-        while (*vars)
-        {
-            sendVariable(std::string(*vars), true, refreshId);
-            vars++;
-        }
+        refreshId = ScilabVariablesRefresh::getScilabVariablesRefreshId(getScilabJavaVM());
     }
 
-    bool ScilabToJava::sendVariable(const std::string & name, bool swaped, int handlerId)
+    char ** vars = ScilabVariables::getAllListenedVariables(getScilabJavaVM());
+    while (*vars)
     {
-        int * addr = 0;
-        SciErr err;
+        sendVariable(std::string(*vars), true, refreshId);
+        vars++;
+    }
+}
 
-        if (!isNamedVarExist(0, name.c_str()))
-        {
-            return false;
-        }
+bool ScilabToJava::sendVariableAsReference(const std::string & name, int handlerId)
+{
+    int * addr = 0;
+    SciErr err;
 
-        err = getVarAddressFromName(0, name.c_str(), &addr);
-        if (err.iErr)
-        {
-            printError(&err, 0);
-            return false;
-        }
+    if (!isNamedVarExist(0, name.c_str()))
+    {
+        return false;
+    }
 
-        std::vector<int> indexes;
-        return sendVariable(name, indexes, addr, swaped, handlerId, 0);
+    err = getVarAddressFromName(0, name.c_str(), &addr);
+    if (err.iErr)
+    {
+        printError(&err, 0);
+        return false;
     }
 
-    bool ScilabToJava::sendVariable(const std::string & name, int * addr, bool swaped, int handlerId, void * pvApiCtx)
+    std::vector<int> indexes;
+    return sendVariable(name, indexes, addr, false, true, handlerId, 0);
+}
+
+bool ScilabToJava::sendVariable(const std::string & name, bool swaped, int handlerId)
+{
+    int * addr = 0;
+    SciErr err;
+
+    if (!isNamedVarExist(0, name.c_str()))
     {
-        std::vector<int> indexes;
-        return sendVariable(name, indexes, addr, swaped, handlerId, pvApiCtx);
+        return false;
     }
 
-    bool ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, int * addr, bool swaped, int handlerId, void * pvApiCtx)
+    err = getVarAddressFromName(0, name.c_str(), &addr);
+    if (err.iErr)
     {
-        SciErr err;
+        printError(&err, 0);
+        return false;
+    }
+
+    std::vector<int> indexes;
+    return sendVariable(name, indexes, addr, swaped, false, handlerId, 0);
+}
+
+bool ScilabToJava::sendVariable(const std::string & name, int * addr, bool swaped, int handlerId, void * pvApiCtx)
+{
+    std::vector<int> indexes;
+    return sendVariable(name, indexes, addr, swaped, false, handlerId, pvApiCtx);
+}
+
+bool ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, int * addr, bool swaped, bool byref, int handlerId, void * pvApiCtx)
+{
+    SciErr err;
 
-        int type;
-        int row;
-        int col;
-        int prec;
+    int type;
+    int row;
+    int col;
+    int prec;
 
-        // Double
-        double * real = 0;
-        double * img = 0;
+    // Double
+    double * real = 0;
+    double * img = 0;
 
-        // Integers
-        char * integers8 = 0;
-        unsigned char * uintegers8 = 0;
-        short * integers16 = 0;
-        unsigned short * uintegers16 = 0;
-        int * integers32 = 0;
-        unsigned int * uintegers32 = 0;
+    // Integers
+    char * integers8 = 0;
+    unsigned char * uintegers8 = 0;
+    short * integers16 = 0;
+    unsigned short * uintegers16 = 0;
+    int * integers32 = 0;
+    unsigned int * uintegers32 = 0;
 
-        // Boolean
-        int * booleans = 0;
+    // Boolean
+    int * booleans = 0;
 
 #ifdef __SCILAB_INT64__
-        long long * integers64 = 0;
-        unsigned long long * uintegers64 = 0;
+    long long * integers64 = 0;
+    unsigned long long * uintegers64 = 0;
 #endif
 
-        // Strings
-        char ** strings = 0;
+    // Strings
+    char ** strings = 0;
 
-        // Sparse
-        int nbItem;
-        int * nbItemRow = 0;
-        int * colPos = 0;
+    // Sparse
+    int nbItem;
+    int * nbItemRow = 0;
+    int * colPos = 0;
 
-        // Polynomial
-        double ** re = 0;
-        double ** im = 0;
-        int rc;
-        int * nbCoeffs = 0;
-        char varName[5];
-        int varNameLen;
+    // Polynomial
+    double ** re = 0;
+    double ** im = 0;
+    int rc;
+    int * nbCoeffs = 0;
+    char varName[5];
+    int varNameLen;
 
-        // Lists
-        char listtype = 0;
+    // Lists
+    char listtype = 0;
+    int nbItems = 0;
 
-        err = getVarType(pvApiCtx, addr, &type);
-        if (err.iErr)
-        {
-            printError(&err, 0);
-            return false;
-        }
+    err = getVarType(pvApiCtx, addr, &type);
+    if (err.iErr)
+    {
+        printError(&err, 0);
+        return false;
+    }
 
-        switch (type)
-        {
+    switch (type)
+    {
         case sci_matrix :
             if (isVarComplex(pvApiCtx, addr))
             {
@@ -129,7 +152,7 @@ namespace org_modules_types
                     return false;
                 }
 
-                sendVariable<double>(name, indexes, row, col, real, img, swaped, handlerId);
+                sendVariable<double>(name, indexes, row, col, real, img, swaped, byref, handlerId);
             }
             else
             {
@@ -140,7 +163,7 @@ namespace org_modules_types
                     return false;
                 }
 
-                sendVariable<double>(name, indexes, row, col, real, swaped, handlerId);
+                sendVariable<double>(name, indexes, row, col, real, swaped, byref, handlerId);
             }
             break;
         case sci_ints :
@@ -153,91 +176,91 @@ namespace org_modules_types
 
             switch (prec)
             {
-            case SCI_INT8 :
-                err = getMatrixOfInteger8(pvApiCtx, addr, &row, &col, &integers8);
-                if (err.iErr)
-                {
-                    printError(&err, 0);
-                    return false;
-                }
+                case SCI_INT8 :
+                    err = getMatrixOfInteger8(pvApiCtx, addr, &row, &col, &integers8);
+                    if (err.iErr)
+                    {
+                        printError(&err, 0);
+                        return false;
+                    }
 
-                sendVariable<byte>(name, indexes, row, col, (byte *)integers8, swaped, handlerId);
-                break;
-            case SCI_UINT8 :
-                err = getMatrixOfUnsignedInteger8(pvApiCtx, addr, &row, &col, &uintegers8);
-                if (err.iErr)
-                {
-                    printError(&err, 0);
-                    return false;
-                }
+                    sendVariable<byte>(name, indexes, row, col, (byte *)integers8, swaped, byref, handlerId);
+                    break;
+                case SCI_UINT8 :
+                    err = getMatrixOfUnsignedInteger8(pvApiCtx, addr, &row, &col, &uintegers8);
+                    if (err.iErr)
+                    {
+                        printError(&err, 0);
+                        return false;
+                    }
 
-                sendUnsignedVariable<byte>(name, indexes, row, col, (byte *)uintegers8, swaped, handlerId);
-                break;
-            case SCI_INT16 :
-                err = getMatrixOfInteger16(pvApiCtx, addr, &row, &col, &integers16);
-                if (err.iErr)
-                {
-                    printError(&err, 0);
-                    return false;
-                }
+                    sendUnsignedVariable<byte>(name, indexes, row, col, (byte *)uintegers8, swaped, byref, handlerId);
+                    break;
+                case SCI_INT16 :
+                    err = getMatrixOfInteger16(pvApiCtx, addr, &row, &col, &integers16);
+                    if (err.iErr)
+                    {
+                        printError(&err, 0);
+                        return false;
+                    }
 
-                sendVariable<short>(name, indexes, row, col, integers16, swaped, handlerId);
-                break;
-            case SCI_UINT16 :
-                err = getMatrixOfUnsignedInteger16(pvApiCtx, addr, &row, &col, &uintegers16);
-                if (err.iErr)
-                {
-                    printError(&err, 0);
-                    return false;
-                }
+                    sendVariable<short>(name, indexes, row, col, integers16, swaped, byref, handlerId);
+                    break;
+                case SCI_UINT16 :
+                    err = getMatrixOfUnsignedInteger16(pvApiCtx, addr, &row, &col, &uintegers16);
+                    if (err.iErr)
+                    {
+                        printError(&err, 0);
+                        return false;
+                    }
 
-                sendUnsignedVariable<short>(name, indexes, row, col, (short *)uintegers16, swaped, handlerId);
-                break;
-            case SCI_INT32 :
-                err = getMatrixOfInteger32(pvApiCtx, addr, &row, &col, &integers32);
-                if (err.iErr)
-                {
-                    printError(&err, 0);
-                    return false;
-                }
+                    sendUnsignedVariable<short>(name, indexes, row, col, (short *)uintegers16, swaped, byref, handlerId);
+                    break;
+                case SCI_INT32 :
+                    err = getMatrixOfInteger32(pvApiCtx, addr, &row, &col, &integers32);
+                    if (err.iErr)
+                    {
+                        printError(&err, 0);
+                        return false;
+                    }
 
-                sendVariable<int>(name, indexes, row, col, integers32, swaped, handlerId);
-                break;
-            case SCI_UINT32 :
-                err = getMatrixOfUnsignedInteger32(pvApiCtx, addr, &row, &col, &uintegers32);
-                if (err.iErr)
-                {
-                    printError(&err, 0);
-                    return false;
-                }
+                    sendVariable<int>(name, indexes, row, col, integers32, swaped, byref, handlerId);
+                    break;
+                case SCI_UINT32 :
+                    err = getMatrixOfUnsignedInteger32(pvApiCtx, addr, &row, &col, &uintegers32);
+                    if (err.iErr)
+                    {
+                        printError(&err, 0);
+                        return false;
+                    }
 
-                sendUnsignedVariable<int>(name, indexes, row, col, (int *)uintegers32, swaped, handlerId);
-                break;
+                    sendUnsignedVariable<int>(name, indexes, row, col, (int *)uintegers32, swaped, byref, handlerId);
+                    break;
 
 #ifdef __SCILAB_INT64__
-            case SCI_INT64 :
-                err = getMatrixOfInteger64(pvApiCtx, addr, &row, &col, &integers64);
-                if (err.iErr)
-                {
-                    printError(&err, 0);
-                    return false;
-                }
+                case SCI_INT64 :
+                    err = getMatrixOfInteger64(pvApiCtx, addr, &row, &col, &integers64);
+                    if (err.iErr)
+                    {
+                        printError(&err, 0);
+                        return false;
+                    }
 
-                sendVariable<long long>(name, indexes, row, col, integers64, swaped, handlerId);
-                break;
-            case SCI_UINT64 :
-                err = getMatrixOfUnsignedInteger64(pvApiCtx, addr, &row, &col, &uintegers64);
-                if (err.iErr)
-                {
-                    printError(&err, 0);
-                    return false;
-                }
+                    sendVariable<long long>(name, indexes, row, col, integers64, swaped, byref, handlerId);
+                    break;
+                case SCI_UINT64 :
+                    err = getMatrixOfUnsignedInteger64(pvApiCtx, addr, &row, &col, &uintegers64);
+                    if (err.iErr)
+                    {
+                        printError(&err, 0);
+                        return false;
+                    }
 
-                sendUnsignedVariable<long long>(name, indexes, row, col, (long long *)uintegers64, swaped, handlerId);
-                break;
+                    sendUnsignedVariable<long long>(name, indexes, row, col, (long long *)uintegers64, swaped, byref, handlerId);
+                    break;
 #endif
-            default :
-                return false;
+                default :
+                    return false;
             }
             break;
         case sci_strings :
@@ -246,7 +269,7 @@ namespace org_modules_types
                 return false;
             }
 
-            sendVariable<char *>(name, indexes, row, col, strings, swaped, handlerId);
+            sendStringVariable(name, indexes, row, col, strings, swaped, false, handlerId);
             freeAllocatedMatrixOfString(row, col, strings);
             break;
         case sci_boolean :
@@ -257,7 +280,7 @@ namespace org_modules_types
                 return false;
             }
 
-            sendConvertedBooleanVariable(name, indexes, row, col, booleans, swaped, handlerId);
+            sendConvertedBooleanVariable(name, indexes, row, col, booleans, swaped, byref, handlerId);
             break;
         case sci_sparse :
             if (isVarComplex(pvApiCtx, addr))
@@ -269,7 +292,7 @@ namespace org_modules_types
                     return 0;
                 }
 
-                sendVariable<double>(name, indexes, nbItem, nbItemRow, colPos, row, col, real, img, handlerId);
+                sendVariable<double>(name, indexes, nbItem, nbItemRow, colPos, row, col, real, img, false, handlerId);
             }
             else
             {
@@ -280,7 +303,7 @@ namespace org_modules_types
                     return 0;
                 }
 
-                sendVariable<double>(name, indexes, nbItem, nbItemRow, colPos, row, col, real, handlerId);
+                sendVariable<double>(name, indexes, nbItem, nbItemRow, colPos, row, col, real, false, handlerId);
             }
             break;
         case sci_boolean_sparse :
@@ -291,7 +314,7 @@ namespace org_modules_types
                 return 0;
             }
 
-            sendBooleanSparseVariable(name, indexes, nbItem, nbItemRow, colPos, row, col, handlerId);
+            sendBooleanSparseVariable(name, indexes, nbItem, nbItemRow, colPos, row, col, false, handlerId);
             delete[] integers8;
             break;
         case sci_poly :
@@ -335,7 +358,7 @@ namespace org_modules_types
                     return false;
                 }
 
-                sendVariable<double>(name, indexes, varName, row, col, nbCoeffs, re, im, swaped, handlerId);
+                sendVariable<double>(name, indexes, varName, row, col, nbCoeffs, re, im, swaped, false, handlerId);
                 for (int i = 0; i < rc; i++)
                 {
                     delete[] im[i];
@@ -368,7 +391,7 @@ namespace org_modules_types
                     return false;
                 }
 
-                sendVariable<double>(name, indexes, varName, row, col, nbCoeffs, re, swaped, handlerId);
+                sendVariable<double>(name, indexes, varName, row, col, nbCoeffs, re, swaped, false, handlerId);
             }
             for (int i = 0; i < rc; i++)
             {
@@ -389,77 +412,84 @@ namespace org_modules_types
             break;
         default :
             return false;
-        }
-
-        if (listtype)
-        {
-            sendVariable(name, indexes, listtype, handlerId);
-            bool b = sendItems(name, indexes, addr, swaped, handlerId, pvApiCtx);
-            closeList(indexes, handlerId);
-            return b;
-        }
-
-        return true;
     }
 
-    inline bool ScilabToJava::sendItems(const std::string & name, std::vector<int> & indexes, int * addr, bool swaped, int handlerId, void * pvApiCtx)
+    if (listtype)
     {
-        int nbItems = 0;
-        int * itemAddr = 0;
-
-        SciErr err = getListItemNumber(pvApiCtx, addr, &nbItems);
+        err = getListItemNumber(pvApiCtx, addr, &nbItems);
         if (err.iErr)
         {
             printError(&err, 0);
             return false;
         }
 
-        for (int i = 1; i <= nbItems; i++)
-        {
-            err = getListItemAddress(pvApiCtx, addr, i, &itemAddr);
-            if (err.iErr)
-            {
-                printError(&err, 0);
-                return false;
-            }
+        sendVariable(name, nbItems, indexes, listtype, false, handlerId);
+        bool b = sendItems(name, nbItems, indexes, addr, swaped, byref, handlerId, pvApiCtx);
+        closeList(indexes, handlerId);
+        return b;
+    }
 
-            indexes.push_back(i);
+    return true;
+}
 
-            if (!sendVariable(name, indexes, itemAddr, swaped, handlerId, pvApiCtx))
-            {
-                return false;
-            }
+inline bool ScilabToJava::sendItems(const std::string & name, const int nbItems, std::vector<int> & indexes, int * addr, bool swaped, bool byref, int handlerId, void * pvApiCtx)
+{
+    int * itemAddr = 0;
+    SciErr err;
 
-            indexes.pop_back();
+    for (int i = 1; i <= nbItems; i++)
+    {
+        err = getListItemAddress(pvApiCtx, addr, i, &itemAddr);
+        if (err.iErr)
+        {
+            printError(&err, 0);
+            return false;
         }
 
-        return true;
-    }
+        indexes.push_back(i);
 
-    inline int * ScilabToJava::getIndexesPointer(std::vector<int> & indexes)
-    {
-        if (indexes.size() == 0)
+        if (!sendVariable(name, indexes, itemAddr, swaped, byref, handlerId, pvApiCtx))
         {
-            return 0;
+            return false;
         }
 
-        return &(indexes[0]);
+        indexes.pop_back();
     }
 
-    // Lists
-    inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, char type, int handlerId)
+    return true;
+}
+
+inline int * ScilabToJava::getIndexesPointer(std::vector<int> & indexes)
+{
+    if (indexes.size() == 0)
     {
-        ScilabVariables::sendData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), type, handlerId);
+        return 0;
     }
 
-    inline void ScilabToJava::closeList(std::vector<int> & indexes, int handlerId)
+    return &(indexes[0]);
+}
+
+// Lists
+// byref is useless
+inline void ScilabToJava::sendVariable(const std::string & name, const int nbItems, std::vector<int> & indexes, char type, bool byref, int handlerId)
+{
+    ScilabVariables::sendData(getScilabJavaVM(), (char *)name.c_str(), nbItems, getIndexesPointer(indexes), (int)indexes.size(), type, handlerId);
+}
+
+inline void ScilabToJava::closeList(std::vector<int> & indexes, int handlerId)
+{
+    ScilabVariables::closeList(getScilabJavaVM(), getIndexesPointer(indexes), (int)indexes.size(), handlerId);
+}
+
+// Sparse
+template<typename T>
+inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, int nbItem, int * nbItemRow, int * colPos, int row, int col, T * data, bool byref, int handlerId)
+{
+    if (byref)
     {
-        ScilabVariables::closeList(getScilabJavaVM(), getIndexesPointer(indexes), (int)indexes.size(), handlerId);
+        ScilabVariables::sendDataAsBuffer(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), row, col, nbItem, nbItemRow, row, colPos, nbItem, data, nbItem, handlerId);
     }
-
-    // Sparse
-    template<typename T>
-    inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, int nbItem, int * nbItemRow, int * colPos, int row, int col, T * data, int handlerId)
+    else
     {
         int * colPos_ = new int[nbItem];
         for (int i = 0; i < nbItem; i++)
@@ -469,18 +499,40 @@ namespace org_modules_types
         ScilabVariables::sendData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), row, col, nbItem, nbItemRow, row, colPos_, nbItem, data, nbItem, handlerId);
         delete[] colPos_;
     }
+}
 
-    // Double, String, ...
-    template<typename T>
-    inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, int row, int col, T * data, bool swaped, int handlerId)
+// Double, ...
+template<typename T>
+inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, int row, int col, T * data, bool swaped, bool byRef, int handlerId)
+{
+    if (byRef)
+    {
+        ScilabVariables::sendDataAsBuffer(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), data, row * col, row, col, handlerId);
+    }
+    else
     {
         T ** addr = getMatrix<T>(row, col, data, swaped);
         ScilabVariables::sendData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), addr, row, col, swaped, handlerId);
         deleteMatrix<T>(addr, swaped);
     }
+}
+
+// String
+inline void ScilabToJava::sendStringVariable(const std::string & name, std::vector<int> & indexes, int row, int col, char ** data, bool swaped, bool byRef, int handlerId)
+{
+    char *** addr = getMatrix<char *>(row, col, data, swaped);
+    ScilabVariables::sendData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), addr, row, col, swaped, handlerId);
+    deleteMatrix<char *>(addr, swaped);
+}
 
-    // Boolean sparse
-    inline void ScilabToJava::sendBooleanSparseVariable(const std::string & name, std::vector<int> & indexes, int nbItem, int * nbItemRow, int * colPos, int row, int col, int handlerId)
+// Boolean sparse
+inline void ScilabToJava::sendBooleanSparseVariable(const std::string & name, std::vector<int> & indexes, int nbItem, int * nbItemRow, int * colPos, int row, int col, bool byref, int handlerId)
+{
+    if (byref)
+    {
+        ScilabVariables::sendDataAsBuffer(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), row, col, nbItem, nbItemRow, row, colPos, nbItem, handlerId);
+    }
+    else
     {
         int * colPos_ = new int[nbItem];
         for (int i = 0; i < nbItem; i++)
@@ -490,50 +542,78 @@ namespace org_modules_types
         ScilabVariables::sendData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), row, col, nbItem, nbItemRow, row, colPos_, nbItem, handlerId);
         delete[] colPos_;
     }
+}
+
+// uint* matrix with a bigger storage
+// TODO : change the Java wrapping
+template<typename T, typename U>
+inline void ScilabToJava::sendUnsignedVariableWithCast(const std::string & name, std::vector<int> & indexes, int row, int col, U * data, bool swaped, int handlerId)
+{
+    T ** addr = getConvertedMatrix<T, U>(row, col, data, swaped);
+    ScilabVariables::sendUnsignedData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), addr, row, col, swaped, handlerId);
+    deleteMatrix<T>(addr, swaped);
+}
 
-    // uint* matrix with a bigger storage
-    // TODO : change the Java wrapping
-    template<typename T, typename U>
-    inline void ScilabToJava::sendUnsignedVariableWithCast(const std::string & name, std::vector<int> & indexes, int row, int col, U * data, bool swaped, int handlerId)
+// uint*
+template<typename T>
+inline void ScilabToJava::sendUnsignedVariable(const std::string & name, std::vector<int> & indexes, int row, int col, T * data, bool swaped, bool byref, int handlerId)
+{
+    if (byref)
     {
-        T ** addr = getConvertedMatrix<T, U>(row, col, data, swaped);
-        ScilabVariables::sendUnsignedData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), addr, row, col, swaped, handlerId);
-        deleteMatrix<T>(addr, swaped);
+        ScilabVariables::sendUnsignedDataAsBuffer(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), data, row * col, row, col, handlerId);
     }
-
-    // uint*
-    template<typename T>
-    inline void ScilabToJava::sendUnsignedVariable(const std::string & name, std::vector<int> & indexes, int row, int col, T * data, bool swaped, int handlerId)
+    else
     {
         T ** addr = getMatrix<T>(row, col, data, swaped);
         ScilabVariables::sendUnsignedData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), addr, row, col, swaped, handlerId);
         deleteMatrix<T>(addr, swaped);
     }
+}
 
-    // Boolean
-    inline void ScilabToJava::sendConvertedBooleanVariable(const std::string & name, std::vector<int> & indexes, int row, int col, int * data, bool swaped, int handlerId)
+// Boolean
+inline void ScilabToJava::sendConvertedBooleanVariable(const std::string & name, std::vector<int> & indexes, int row, int col, int * data, bool swaped, bool byref, int handlerId)
+{
+    if (byref)
+    {
+        ScilabVariables::sendBooleanDataAsBuffer(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), data, row * col, row, col, handlerId);
+    }
+    else
     {
         bool ** addr = getConvertedMatrix<bool, int>(row, col, data, swaped);
         ScilabVariables::sendData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), addr, row, col, swaped, handlerId);
         deleteMatrix<bool>(addr, swaped);
     }
+}
 
-    // Complex sparse
-    template<typename T>
-    inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, int nbItem, int * nbItemRow, int * colPos, int row, int col, T * real, T * img, int handlerId)
+// Complex sparse
+template<typename T>
+inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, int nbItem, int * nbItemRow, int * colPos, int row, int col, T * real, T * img, bool byref, int handlerId)
+{
+    if (byref)
+    {
+        ScilabVariables::sendDataAsBuffer(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), row, col, nbItem, nbItemRow, row, colPos, nbItem, real, nbItem, img, nbItem, handlerId);
+    }
+    else
     {
         int * colPos_ = new int[nbItem];
         for (int i = 0; i < nbItem; i++)
         {
             colPos_[i] = colPos[i] - 1;
         }
-        ScilabVariables::sendData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(),  row, col, nbItem, nbItemRow, row, colPos_, nbItem, real, nbItem, img, nbItem, handlerId);
+        ScilabVariables::sendData(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), row, col, nbItem, nbItemRow, row, colPos_, nbItem, real, nbItem, img, nbItem, handlerId);
         delete[] colPos_;
     }
+}
 
-    // Complex
-    template<typename T>
-    inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, int row, int col, T * real, T * img, bool swaped, int handlerId)
+// Complex
+template<typename T>
+inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, int row, int col, T * real, T * img, bool swaped, bool byref, int handlerId)
+{
+    if (byref)
+    {
+        ScilabVariables::sendDataAsBuffer(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), real, row * col, img, row * col, row, col, handlerId);
+    }
+    else
     {
         T ** re = getMatrix<T>(row, col, real, swaped);
         T ** im = getMatrix<T>(row, col, img, swaped);
@@ -541,125 +621,133 @@ namespace org_modules_types
         deleteMatrix<T>(re, swaped);
         deleteMatrix<T>(im, swaped);
     }
+}
 
-    // Polynomial
-    template<typename T>
-    inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, const char * varName, int row, int col, int * nbcoeff, T ** data, bool swaped, int handlerId)
-    {
-        T *** addr = getMatrix<T*>(row, col, data, swaped);
-        int ** nbc = getMatrix<int>(row, col, nbcoeff, swaped);
-        ScilabPolynomialToJava::sendPolynomial(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), (char *)varName, addr, row, col, nbc, swaped, handlerId);
-        deleteMatrix<T*>(addr, swaped);
-        deleteMatrix<int>(nbc, swaped);
-    }
+// Polynomial
+// byref is useless
+template<typename T>
+inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, const char * varName, int row, int col, int * nbcoeff, T ** data, bool swaped, bool byref, int handlerId)
+{
+    T *** addr = getMatrix<T*>(row, col, data, swaped);
+    int ** nbc = getMatrix<int>(row, col, nbcoeff, swaped);
+    ScilabPolynomialToJava::sendPolynomial(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), (char *)varName, addr, row, col, nbc, swaped, handlerId);
+    deleteMatrix<T*>(addr, swaped);
+    deleteMatrix<int>(nbc, swaped);
+}
 
-    // Complex polynomial
-    template<typename T>
-    inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, const char * varName, int row, int col, int * nbcoeff, T ** real, T ** img, bool swaped, int handlerId)
-    {
-        T *** re = getMatrix<T*>(row, col, real, swaped);
-        T *** im = getMatrix<T*>(row, col, img, swaped);
-        int ** nbc = getMatrix<int>(row, col, nbcoeff, swaped);
-        ScilabPolynomialToJava::sendPolynomial(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), (char *)varName, re, im, row, col, nbc, swaped, handlerId);
-        deleteMatrix<T*>(re, swaped);
-        deleteMatrix<T*>(im, swaped);
-        deleteMatrix<int>(nbc, swaped);
-    }
+// Complex polynomial
+// byref is useless
+template<typename T>
+inline void ScilabToJava::sendVariable(const std::string & name, std::vector<int> & indexes, const char * varName, int row, int col, int * nbcoeff, T ** real, T ** img, bool swaped, bool byref, int handlerId)
+{
+    T *** re = getMatrix<T*>(row, col, real, swaped);
+    T *** im = getMatrix<T*>(row, col, img, swaped);
+    int ** nbc = getMatrix<int>(row, col, nbcoeff, swaped);
+    ScilabPolynomialToJava::sendPolynomial(getScilabJavaVM(), (char *)name.c_str(), getIndexesPointer(indexes), (int)indexes.size(), (char *)varName, re, im, row, col, nbc, swaped, handlerId);
+    deleteMatrix<T*>(re, swaped);
+    deleteMatrix<T*>(im, swaped);
+    deleteMatrix<int>(nbc, swaped);
+}
 
-    template<typename T>
-    inline T ** ScilabToJava::getMatrix(int row, int col, T * data, bool swaped)
-    {
-        T ** addr = 0;
+template<typename T>
+inline T ** ScilabToJava::getMatrix(int row, int col, T * data, bool swaped)
+{
+    T ** addr = 0;
 
-        if (row && col)
+    if (row && col)
+    {
+        if (swaped)
         {
-            if (swaped)
+            T * d = new T[row * col];
+            for (int i = 0; i < row; i++)
             {
-                T * d = new T[row * col];
-                for (int i = 0; i < row; i++)
+                for (int j = 0; j < col; j++)
                 {
-                    for (int j = 0; j < col; j++)
-                    {
-                        d[i * col + j] = data[j * row + i];
-                    }
+                    d[i * col + j] = data[j * row + i];
                 }
-                addr = convertMatrix<T>(row, col, d);
-            }
-            else
-            {
-                addr = convertMatrix<T>(col, row, data);
             }
+            addr = convertMatrix<T>(row, col, d);
+        }
+        else
+        {
+            addr = convertMatrix<T>(col, row, data);
         }
-
-        return addr;
     }
 
-    template<typename T, typename U>
-    inline T ** ScilabToJava::getConvertedMatrix(int row, int col, U * data, bool swaped)
-    {
-        T ** addr = 0;
+    return addr;
+}
+
+template<typename T, typename U>
+inline T ** ScilabToJava::getConvertedMatrix(int row, int col, U * data, bool swaped)
+{
+    T ** addr = 0;
 
-        if (row && col)
+    if (row && col)
+    {
+        int rc = row * col;
+        T * d = new T[rc];
+        if (swaped)
         {
-            int rc = row * col;
-            T * d = new T[rc];
-            if (swaped)
+            for (int i = 0; i < row; i++)
             {
-                for (int i = 0; i < row; i++)
+                for (int j = 0; j < col; j++)
                 {
-                    for (int j = 0; j < col; j++)
-                    {
-                        d[i * col + j] = static_cast<T>(data[j * row + i]);
-                    }
+                    d[i * col + j] = static_cast<T>(data[j * row + i]);
                 }
-                addr = convertMatrix<T>(row, col, d);
             }
-            else
+            addr = convertMatrix<T>(row, col, d);
+        }
+        else
+        {
+            for (int i = 0; i < rc; i++)
             {
-                for (int i = 0; i < rc; i++)
-                {
-                    d[i] = static_cast<T>(data[i]);
-                }
-                addr = convertMatrix<T>(col, row, d);
+                d[i] = static_cast<T>(data[i]);
             }
+            addr = convertMatrix<T>(col, row, d);
         }
-
-        return addr;
     }
 
-    template<typename T>
-    inline T ** ScilabToJava::convertMatrix(int row, int col, T * data)
-    {
-        T ** addr = 0;
+    return addr;
+}
+
+template<typename T>
+inline T ** ScilabToJava::convertMatrix(int row, int col, T * data)
+{
+    T ** addr = 0;
 
-        if (row && col)
+    if (row && col)
+    {
+        addr = new T*[row];
+        *addr = data;
+        for (int i = 1; i < row; i++)
         {
-            addr = new T*[row];
-            *addr = data;
-            for (int i = 1; i < row; i++)
-            {
-                addr[i] = addr[i - 1] + col;
-            }
+            addr[i] = addr[i - 1] + col;
         }
-
-        return addr;
     }
 
-    template<typename T>
-    inline void ScilabToJava::deleteMatrix(T ** data, bool swaped)
+    return addr;
+}
+
+template<typename T>
+inline void ScilabToJava::deleteMatrix(T ** data, bool swaped)
+{
+    if (data)
     {
-        if (data)
+        if (swaped && *data)
         {
-            if (swaped && *data)
-            {
-                delete[] *data;
-            }
-            delete[] data;
+            delete[] *data;
         }
+        delete[] data;
     }
 }
+}
 
 void getScilabVariable(const char * variableName, int swapRowCol, int handlerId)
 {
     org_modules_types::ScilabToJava::sendVariable(std::string(variableName), swapRowCol != 0, handlerId);
 }
+
+void getScilabVariableAsReference(const char * variableName, int handlerId)
+{
+    org_modules_types::ScilabToJava::sendVariableAsReference(std::string(variableName), handlerId);
+}
index 86867c8..91bb0a4 100644 (file)
@@ -9,22 +9,26 @@
 package org.scilab.modules.types;
 
 
- /**
-   * Connector for Javasci v2.
-   * This class should <b>not</b> be used directly
-   * @see org.scilab.modules.javasci.Scilab
-   * @author DIGITEO - Sylvestre LEDRU
-   */
+/**
+  * Connector for Javasci v2.
+  * This class should <b>not</b> be used directly
+  * @see org.scilab.modules.javasci.Scilab
+  * @author DIGITEO - Sylvestre LEDRU
+  */
 public class GetScilabVariable {
 
- /**
-   * Constructor
-   */
- protected GetScilabVariable() {
-    throw new UnsupportedOperationException();
- }
-  public static void getScilabVariable(String variableName, int arg1, int arg2) {
-    GetScilabVariableJNI.getScilabVariable(variableName, arg1, arg2);
-  }
+    /**
+      * Constructor
+      */
+    protected GetScilabVariable() {
+        throw new UnsupportedOperationException();
+    }
+    public static void getScilabVariable(String variableName, int arg1, int arg2) {
+        GetScilabVariableJNI.getScilabVariable(variableName, arg1, arg2);
+    }
+
+    public static void getScilabVariableAsReference(String variableName, int arg1) {
+        GetScilabVariableJNI.getScilabVariableAsReference(variableName, arg1);
+    }
 
 }
index e354569..81e42f3 100644 (file)
@@ -11,36 +11,37 @@ package org.scilab.modules.types;
 
 /* It is generated code. Disable checkstyle */
 //CHECKSTYLE:OFF
- /**
-   * Connector for Javasci v2.
-   * This class should <b>not</b> be used directly
-   * @see org.scilab.modules.javasci.Scilab
-   * @author DIGITEO - Sylvestre LEDRU
-   */
+/**
+  * Connector for Javasci v2.
+  * This class should <b>not</b> be used directly
+  * @see org.scilab.modules.javasci.Scilab
+  * @author DIGITEO - Sylvestre LEDRU
+  */
 class GetScilabVariableJNI {
 
-  /**
-    * Constructor
-    */
-  protected GetScilabVariableJNI() {
-    throw new UnsupportedOperationException();
-  }
+    /**
+      * Constructor
+      */
+    protected GetScilabVariableJNI() {
+        throw new UnsupportedOperationException();
+    }
 
-  static {
-    try {
-        if (System.getProperty("os.name").toLowerCase().contains("windows")) {
-           System.loadLibrary("scitypes");
-        } else {
-           System.loadLibrary("scilab");
+    static {
+        try {
+            if (System.getProperty("os.name").toLowerCase().contains("windows")) {
+                System.loadLibrary("scitypes");
+            } else {
+                System.loadLibrary("scilab");
+            }
+        } catch (SecurityException e) {
+            System.err.println("A security manager exists and does not allow the loading of the specified dynamic library :");
+            e.printStackTrace(System.err);
+        } catch (UnsatisfiedLinkError e)    {
+            System.err.println("The native library libscilab does not exist or cannot be found.");
+            e.printStackTrace(System.err);
         }
-    } catch (SecurityException e) {
-        System.err.println("A security manager exists and does not allow the loading of the specified dynamic library :");
-        e.printStackTrace(System.err);
-    } catch (UnsatisfiedLinkError e)    {
-        System.err.println("The native library libscilab does not exist or cannot be found.");
-        e.printStackTrace(System.err);
     }
-  }
 
-  public final static native void getScilabVariable(String jarg1, int jarg2, int jarg3);
+    public final static native void getScilabVariable(String jarg1, int jarg2, int jarg3);
+    public final static native void getScilabVariableAsReference(String jarg1, int jarg2);
 }
index f4727fc..ed95651 100644 (file)
@@ -17,7 +17,6 @@ package org.scilab.modules.types;
 import java.io.IOException;
 import java.io.ObjectInput;
 import java.io.ObjectOutput;
-import java.util.Arrays;
 
 /**
  * This class provides a representation on the Scilab boolean datatype<br>
@@ -41,9 +40,10 @@ public class ScilabBoolean implements ScilabType {
     private static final int VERSION = 0;
 
     /* the boolean data */
-    private boolean[][] data;
-    private String varName;
-    private boolean swaped;
+    protected boolean[][] data;
+    protected String varName;
+    protected boolean swaped;
+    transient protected boolean byref;
 
     /**
      * Create an empty object
@@ -86,6 +86,13 @@ public class ScilabBoolean implements ScilabType {
     }
 
     /**
+     * {@inheritDoc}
+     */
+    public boolean isReference() {
+        return byref;
+    }
+
+    /**
      * Change the value with the provided data
      *
      * @param data
@@ -105,6 +112,33 @@ public class ScilabBoolean implements ScilabType {
     }
 
     /**
+     * @return the data
+     */
+    public Object getRawData() {
+        return data;
+    }
+
+    /**
+     * Get the element at position (i, j)
+     * @param i the first coordinate
+     * @param j the second coordinate
+     * @return the corresponding boolean
+     */
+    public boolean getElement(final int i, final int j) {
+        return data[i][j];
+    }
+
+    /**
+     * Set the element at position (i, j)
+     * @param i the first coordinate
+     * @param j the second coordinate
+     * @param x the new value
+     */
+    public void setElement(final int i, final int j, final boolean x) {
+        data[i][j] = x;
+    }
+
+    /**
      * {@inheritDoc}
      */
     public String getVarName() {
@@ -162,7 +196,7 @@ public class ScilabBoolean implements ScilabType {
      */
     @Override
     public boolean isEmpty() {
-        return (data == null);
+        return data == null;
     }
 
     /**
@@ -171,17 +205,26 @@ public class ScilabBoolean implements ScilabType {
     @Override
     public boolean equals(Object obj) {
         if (obj instanceof ScilabBoolean) {
-            return Arrays.deepEquals(this.getData(), ((ScilabBoolean) obj).getData());
-        } else {
-            return false;
+            ScilabBoolean sciBool = (ScilabBoolean) obj;
+            if (isEmpty() && sciBool.isEmpty()) {
+                return true;
+            }
+
+            if (this.getWidth() != sciBool.getWidth() || this.getHeight() != sciBool.getHeight()) {
+                return false;
+            }
+
+            return ScilabTypeUtils.equalsBoolean(this.getRawData(), this.isSwaped(), sciBool.getRawData(), sciBool.isSwaped());
         }
+
+        return false;
     }
 
     /**
      * {@inheritDoc}
      */
     public Object getSerializedObject() {
-        return data;
+        return getData();
     }
 
     @Override
@@ -201,7 +244,7 @@ public class ScilabBoolean implements ScilabType {
     @Override
     public void writeExternal(ObjectOutput out) throws IOException {
         out.writeInt(VERSION);
-        out.writeObject(data);
+        out.writeObject(getData());
         out.writeObject(varName);
         out.writeBoolean(swaped);
     }
@@ -217,14 +260,13 @@ public class ScilabBoolean implements ScilabType {
         StringBuilder result = new StringBuilder();
 
         if (isEmpty()) {
-            result.append("[]");
-            return result.toString();
+            return "[]";
         }
 
         result.append("[");
         for (int i = 0; i < getHeight(); ++i) {
             for (int j = 0; j < getWidth(); ++j) {
-                if (getData()[i][j]) {
+                if (getElement(i, j)) {
                     result.append("%t");
                 } else {
                     result.append("%f");
diff --git a/scilab/modules/types/src/java/org/scilab/modules/types/ScilabBooleanReference.java b/scilab/modules/types/src/java/org/scilab/modules/types/ScilabBooleanReference.java
new file mode 100644 (file)
index 0000000..cf6ddd7
--- /dev/null
@@ -0,0 +1,135 @@
+/*
+ *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ *  Copyright (C) 2009-2009 - DIGITEO - Bruno JOFRET
+ *  Copyright (C) 2010-2010 - DIGITEO - Clement DAVID
+ *  Copyright (C) 2011-2011 - DIGITEO - Calixte DENIZET
+ *
+ *  This file must be used under the terms of the CeCILL.
+ *  This source file is licensed as described in the file COPYING, which
+ *  you should have received as part of this distribution.  The terms
+ *  are also available at
+ *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ */
+
+package org.scilab.modules.types;
+
+import java.io.ObjectStreamException;
+import java.nio.IntBuffer;
+
+/**
+ * This class provides a representation on the Scilab boolean datatype<br>
+ * <br>
+ * This class is {@link java.io.Serializable} and any modification could impact
+ * load and store of data (Xcos files, Javasci saved data, etc...).<br>
+ * <br>
+ * Example:<br />
+ * <code>
+ * boolean [][]a={{true,false,true}, {true,true,true}};<br />
+ * ScilabBoolean aMatrix = new ScilabBoolean(a);
+ * </code>
+ *
+ * @see org.scilab.modules.javasci.Scilab
+ */
+public class ScilabBooleanReference extends ScilabBoolean {
+
+    private IntBuffer intBuffer;
+    private final int nbRows;
+    private final int nbCols;
+
+    /**
+     * Create an object from an array of array of boolean
+     *
+     * @param data
+     *            the array of boolean
+     */
+    public ScilabBooleanReference(String varName, IntBuffer data, int nbRows, int nbCols) {
+        this.varName = varName;
+        this.intBuffer = data;
+        this.swaped = false;
+        this.nbRows = nbRows;
+        this.nbCols = nbCols;
+        this.byref = true;
+    }
+
+    /**
+     * Check the emptiness of the associated data.
+     *
+     * @return true, if the associated data array is empty.
+     */
+    @Override
+    public boolean isEmpty() {
+        return nbRows == 0 || nbCols == 0;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public boolean getElement(final int i, final int j) {
+        return intBuffer.get(i + nbRows * j) != 0;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public void setElement(final int i, final int j, final boolean x) {
+        intBuffer.put(i + nbRows * j, x ? 1 : 0);
+    }
+
+    /**
+     * Change the value with the provided data
+     *
+     * @param data
+     *            array of boolean
+     */
+    public void setData(boolean[][] data) {
+        ScilabTypeUtils.setPart(intBuffer, data);
+    }
+
+    /**
+     * Return the data
+     *
+     * @return the array of array of boolean
+     */
+    public boolean[][] getData() {
+        boolean[][] b = new boolean[nbRows][nbCols];
+        ScilabTypeUtils.setBuffer(b, intBuffer);
+
+        return b;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public Object getRawData() {
+        return intBuffer;
+    }
+
+    /**
+     * When this object is deserialized we want a ScilabBoolean, not a ScilabBooleanReference.
+     * @return a ScilabDouble
+     */
+    private Object readResolve() throws ObjectStreamException {
+        return new ScilabBoolean(varName, data, swaped);
+    }
+
+    /**
+     * Return the height (number of element) of the stored data
+     *
+     * @return the height
+     */
+    @Override
+    public int getHeight() {
+        return nbRows;
+    }
+
+    /**
+     * Return the width (number of element) of the stored data
+     *
+     * @return the width
+     */
+    @Override
+    public int getWidth() {
+        return nbCols;
+    }
+}
index bd7dfd9..efeca4b 100644 (file)
@@ -162,6 +162,13 @@ public class ScilabBooleanSparse implements ScilabType {
     }
 
     /**
+     * {@inheritDoc}
+     */
+    public boolean isReference() {
+        return false;
+    }
+
+    /**
      * Return the type of Scilab
      *
      * @return the type of Scilab
index 9a23e51..789ab83 100644 (file)
@@ -47,10 +47,11 @@ public class ScilabDouble implements ScilabType {
 
     private static final int VERSION = 0;
 
-    private double[][] realPart;
-    private double[][] imaginaryPart;
-    private String varName;
-    private boolean swaped;
+    protected double[][] realPart;
+    protected double[][] imaginaryPart;
+    protected String varName;
+    protected boolean swaped;
+    transient protected boolean byref;
 
     /**
      * Default constructor
@@ -155,6 +156,13 @@ public class ScilabDouble implements ScilabType {
     }
 
     /**
+     * {@inheritDoc}
+     */
+    public boolean isReference() {
+        return byref;
+    }
+
+    /**
      * Check if the current data doesn't have an imaginary part.
      *
      * @return true, if the data are real only.
@@ -216,6 +224,84 @@ public class ScilabDouble implements ScilabType {
     }
 
     /**
+     * Get the element at position (i, j) in the real part
+     * @param i the first coordinate
+     * @param j the second coordinate
+     * @return the corresponding double
+     */
+    public double getRealElement(final int i, final int j) {
+        return realPart[i][j];
+    }
+
+    /**
+     * Get the element at position (i, j) in the imaginary part
+     * @param i the first coordinate
+     * @param j the second coordinate
+     * @return the corresponding double
+     */
+    public double getImaginaryElement(final int i, final int j) {
+        return imaginaryPart[i][j];
+    }
+
+    /**
+     * Get the complex at position (i, j) as a 2-length row-vector
+     * @param i the first coordinate
+     * @param j the second coordinate
+     * @return the corresponding complex
+     */
+    public double[] getElement(final int i, final int j) {
+        return new double[] {getRealElement(i, j), getImaginaryElement(i, j)};
+    }
+
+    /**
+     * Set the element at position (i, j) in the real part
+     * @param i the first coordinate
+     * @param j the second coordinate
+     * @param x the new value
+     */
+    public void setRealElement(final int i, final int j, final double x) {
+        realPart[i][j] = x;
+    }
+
+    /**
+     * Set the element at position (i, j) in the imaginary part
+     * @param i the first coordinate
+     * @param j the second coordinate
+     * @param x the new value
+     */
+    public void setImaginaryElement(final int i, final int j, final double x) {
+        imaginaryPart[i][j] = x;
+    }
+
+    /**
+     * Set the element at position (i, j)
+     * @param i the first coordinate
+     * @param j the second coordinate
+     * @param x the new value for real part
+     * @param y the new value for imaginary part
+     */
+    public void setElement(final int i, final int j, final double x, final double y) {
+        realPart[i][j] = x;
+        imaginaryPart[i][j] = y;
+    }
+
+    /**
+     * Get the raw data
+     * @return the real part
+     */
+    public Object getRawRealPart() {
+        return realPart;
+    }
+
+    /**
+     * Get the raw data
+     * @return the imaginary part
+     */
+    public Object getRawImaginaryPart() {
+        return imaginaryPart;
+    }
+
+    /**
      * Get complex matrix as a serialized form
      *
      * @return the serialized matrix with complex values
@@ -225,8 +311,8 @@ public class ScilabDouble implements ScilabType {
         double[] serializedComplexMatrix = new double[size * 2];
         for (int i = 0; i < this.getHeight(); i++) {
             for (int j = 0; j < this.getWidth(); j++) {
-                serializedComplexMatrix[j * this.getHeight() + i] = realPart[i][j];
-                serializedComplexMatrix[size + j * this.getHeight() + i] = imaginaryPart[i][j];
+                serializedComplexMatrix[j * this.getHeight() + i] = getRealElement(i, j);
+                serializedComplexMatrix[size + j * this.getHeight() + i] = getImaginaryElement(i, j);
             }
         }
 
@@ -238,9 +324,9 @@ public class ScilabDouble implements ScilabType {
      */
     public Object getSerializedObject() {
         if (isReal()) {
-            return new Object[] { realPart };
+            return new Object[] { getRealPart() };
         } else {
-            return new Object[] { realPart, imaginaryPart };
+            return new Object[] { getRealPart(), getImaginaryPart() };
         }
     }
 
@@ -275,21 +361,25 @@ public class ScilabDouble implements ScilabType {
     @Override
     public boolean equals(Object obj) {
         if (obj instanceof ScilabDouble) {
-            ScilabDouble sciDouble = ((ScilabDouble) obj);
+            ScilabDouble sciDouble = (ScilabDouble) obj;
             if (isEmpty() && sciDouble.isEmpty()) {
                 return true;
             }
 
+            if (this.getWidth() != sciDouble.getWidth() || this.getHeight() != sciDouble.getHeight()) {
+                return false;
+            }
+
             if (this.isReal() && sciDouble.isReal()) {
-                return Arrays.deepEquals(this.getRealPart(), sciDouble.getRealPart());
-            } else {
+                return ScilabTypeUtils.equalsDouble(this.getRawRealPart(), this.isSwaped(), sciDouble.getRawRealPart(), sciDouble.isSwaped());
+            } else if (!this.isReal() && !sciDouble.isReal()) {
                 /* Complex */
-                return Arrays.deepEquals(this.getRealPart(), sciDouble.getRealPart())
-                       && Arrays.deepEquals(this.getImaginaryPart(), sciDouble.getImaginaryPart());
+                return ScilabTypeUtils.equalsDouble(this.getRawRealPart(), this.isSwaped(), sciDouble.getRawRealPart(), sciDouble.isSwaped())
+                       && ScilabTypeUtils.equalsDouble(this.getRawImaginaryPart(), this.isSwaped(), sciDouble.getRawImaginaryPart(), sciDouble.isSwaped());
             }
-        } else {
-            return false;
         }
+
+        return false;
     }
 
     @Override
@@ -310,8 +400,8 @@ public class ScilabDouble implements ScilabType {
     @Override
     public void writeExternal(ObjectOutput out) throws IOException {
         out.writeInt(VERSION);
-        out.writeObject(realPart);
-        out.writeObject(imaginaryPart);
+        out.writeObject(getRealPart());
+        out.writeObject(getImaginaryPart());
         out.writeObject(varName);
         out.writeBoolean(swaped);
     }
@@ -332,15 +422,19 @@ public class ScilabDouble implements ScilabType {
         }
 
         result.append("[");
+        final boolean real = isReal();
         for (int i = 0; i < getHeight(); ++i) {
             for (int j = 0; j < getWidth(); ++j) {
-                if (isReal()) {
-                    result.append(Double.toString(realPart[i][j]));
-                } else {
-                    result.append(Double.toString(realPart[i][j]));
-                    result.append(" + ");
-                    result.append(Double.toString(imaginaryPart[i][j]));
-                    result.append(" * %i");
+                result.append(Double.toString(getRealElement(i, j)));
+                if (!real) {
+                    final double y = getImaginaryElement(i, j);
+                    if (y != 0) {
+                        if (y > 0) {
+                            result.append("+");
+                        }
+                        result.append(Double.toString(y));
+                        result.append("*%i");
+                    }
                 }
                 if (j != getWidth() - 1) {
                     result.append(", ");
@@ -354,5 +448,4 @@ public class ScilabDouble implements ScilabType {
 
         return result.toString();
     }
-
 }
diff --git a/scilab/modules/types/src/java/org/scilab/modules/types/ScilabDoubleReference.java b/scilab/modules/types/src/java/org/scilab/modules/types/ScilabDoubleReference.java
new file mode 100644 (file)
index 0000000..555966f
--- /dev/null
@@ -0,0 +1,210 @@
+/*
+ *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ *  Copyright (C) 2009-2009 - DIGITEO - Bruno JOFRET
+ *  Copyright (C) 2010-2010 - DIGITEO - Clement DAVID
+ *  Copyright (C) 2011-2011 - DIGITEO - Calixte DENIZET
+ *
+ *  This file must be used under the terms of the CeCILL.
+ *  This source file is licensed as described in the file COPYING, which
+ *  you should have received as part of this distribution.  The terms
+ *  are also available at
+ *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ */
+
+package org.scilab.modules.types;
+
+import java.io.ObjectStreamException;
+import java.nio.DoubleBuffer;
+
+/**
+ * This class provides a representation on the Scilab Double datatype<br>
+ * Note that double is the default datatype in Scilab.<br>
+ * <br>
+ * This class is {@link java.io.Serializable} and any modification could impact
+ * load and store of data (Xcos files, Javasci saved data, etc...).<br>
+ * <br>
+ * Example (real):<br />
+ * <code>
+ * double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};<br />
+ * ScilabDouble aMatrix = new ScilabDouble(a);<br />
+ * </code> <br>
+ * Example (complex):<br />
+ * <code>
+ * double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};<br />
+ * double [][]aImg={{210.2, 220.0, 420.0, 390.0},{230.2, 240.0, 440.0, 400.0}};<br />
+ * ScilabDouble aMatrix = new ScilabDouble(a, aImg);
+ * </code>
+ *
+ * @see org.scilab.modules.javasci.Scilab
+ */
+public class ScilabDoubleReference extends ScilabDouble {
+
+    private DoubleBuffer realBuffer;
+    private DoubleBuffer imaginaryBuffer;
+    private final int nbRows;
+    private final int nbCols;
+
+    /**
+     * Constructor with a matrix of complex numbers
+     *
+     * @param realData
+     *            the real part of the data
+     * @param imagData
+     *            the imaginary part of the data
+     */
+    ScilabDoubleReference(String varName, DoubleBuffer realBuffer, DoubleBuffer imagBuffer, int nbRows, int nbCols) {
+        this.realBuffer = realBuffer;
+        this.imaginaryBuffer = imagBuffer;
+        this.nbRows = nbRows;
+        this.nbCols = nbCols;
+        this.varName = varName;
+        this.byref = true;
+        this.swaped = false;
+    }
+
+    /**
+     * Check the emptiness of the associated data.
+     *
+     * @return true, if the associated data array is empty.
+     */
+    @Override
+    public boolean isEmpty() {
+        return nbRows == 0 || nbCols == 0;
+    }
+
+    /**
+     * Check if the current data doesn't have an imaginary part.
+     *
+     * @return true, if the data are real only.
+     */
+    public boolean isReal() {
+        return imaginaryBuffer == null || imaginaryBuffer.capacity() == 0;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public Object getRawRealPart() {
+        return realBuffer;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public Object getRawImaginaryPart() {
+        return imaginaryBuffer;
+    }
+
+    /**
+     * Get the real part as DoubleBuffer
+     * @return the real part
+     */
+    public DoubleBuffer getRealBuffer() {
+        return realBuffer;
+    }
+
+    /**
+     * Get the imaginary part as DoubleBuffer
+     * @return the imaginary part
+     */
+    public DoubleBuffer getImaginaryBuffer() {
+        return imaginaryBuffer;
+    }
+
+    /**
+     * Get the real part of the data.
+     *
+     * @return the real part.
+     */
+    public double[][] getRealPart() {
+        double[][] d = new double[nbRows][nbCols];
+        ScilabTypeUtils.setBuffer(d, realBuffer);
+        return d;
+    }
+
+    /**
+     * Set the real part of the data.
+     *
+     * @param realPart
+     *            the real part.
+     */
+    public void setRealPart(double[][] realPart) {
+        ScilabTypeUtils.setPart(realBuffer, realPart);
+    }
+
+    /**
+     * Get the imaginary part of the data.
+     *
+     * @return the imaginary part.
+     */
+    public double[][] getImaginaryPart() {
+        double[][] d = new double[nbRows][nbCols];
+        ScilabTypeUtils.setBuffer(d, imaginaryBuffer);
+        return d;
+    }
+
+    /**
+     * Set the imaginary part of the data.
+     *
+     * @param imaginaryPart
+     *            the imaginary part.
+     */
+    public void setImaginaryPart(double[][] imaginaryPart) {
+        ScilabTypeUtils.setPart(imaginaryBuffer, imaginaryPart);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public double getRealElement(final int i, final int j) {
+        return realBuffer.get(i + nbRows * j);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public double getImaginaryElement(final int i, final int j) {
+        return imaginaryBuffer.get(i + nbRows * j);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public void setRealElement(final int i, final int j, final double x) {
+        realBuffer.put(i + nbRows * j, x);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public void setImaginaryElement(final int i, final int j, final double x) {
+        imaginaryBuffer.put(i + nbRows * j, x);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public void setElement(final int i, final int j, final double x, final double y) {
+        realBuffer.put(i + nbRows * j, x);
+        imaginaryBuffer.put(i + nbRows * j, x);
+    }
+
+    /**
+     * When this object is deserialized we want a ScilabDouble, not a ScilabDoubleReference.
+     * @return a ScilabDouble
+     */
+    private Object readResolve() throws ObjectStreamException {
+        return new ScilabDouble(varName, realPart, imaginaryPart, swaped);
+    }
+
+    @Override
+    public int getHeight() {
+        return nbRows;
+    }
+
+    @Override
+    public int getWidth() {
+        return nbCols;
+    }
+}
index 4671197..fe46ea8 100644 (file)
@@ -16,7 +16,6 @@ package org.scilab.modules.types;
 import java.io.IOException;
 import java.io.ObjectInput;
 import java.io.ObjectOutput;
-import java.util.Arrays;
 
 /**
  * This class provides a representation on the Scilab Integer datatype<br>
@@ -39,20 +38,19 @@ public class ScilabInteger implements ScilabType {
 
     private static final int VERSION = 0;
 
-    private long[][] longData = null;
-    private short[][] shortData = null;
-    private int[][] intData = null;
-    private byte[][] byteData = null;
-    private ScilabIntegerTypeEnum precision;
-    private String varName;
-    private boolean swaped;
+    protected long[][] longData;
+    protected short[][] shortData;
+    protected int[][] intData;
+    protected byte[][] byteData;
+    protected ScilabIntegerTypeEnum precision;
+    protected String varName;
+    protected boolean swaped;
+    transient protected boolean byref;
 
     /**
      * Default constructor
      */
-    public ScilabInteger() {
-
-    }
+    public ScilabInteger() { }
 
     /**
      * Constructor with values
@@ -207,6 +205,50 @@ public class ScilabInteger implements ScilabType {
     }
 
     /**
+     * Constructor with single signed value
+     *
+     * @param value
+     *            the unique value
+     */
+    public ScilabInteger(byte value, boolean bUnsigned) {
+        this(value);
+        this.precision = bUnsigned ? ScilabIntegerTypeEnum.sci_uint8 : ScilabIntegerTypeEnum.sci_int8;
+    }
+
+    /**
+     * Constructor with single signed value
+     *
+     * @param value
+     *            the unique value
+     */
+    public ScilabInteger(short value, boolean bUnsigned) {
+        this(value);
+        this.precision = bUnsigned ? ScilabIntegerTypeEnum.sci_uint16 : ScilabIntegerTypeEnum.sci_int16;
+    }
+
+    /**
+     * Constructor with single signed value
+     *
+     * @param value
+     *            the unique value
+     */
+    public ScilabInteger(int value, boolean bUnsigned) {
+        this(value);
+        this.precision = bUnsigned ? ScilabIntegerTypeEnum.sci_uint32 : ScilabIntegerTypeEnum.sci_int32;
+    }
+
+    /**
+     * Constructor with single signed value
+     *
+     * @param value
+     *            the unique value
+     */
+    public ScilabInteger(long value, boolean bUnsigned) {
+        this(value);
+        this.precision = bUnsigned ? ScilabIntegerTypeEnum.sci_uint64 : ScilabIntegerTypeEnum.sci_int64;
+    }
+
+    /**
      * Set the current values
      *
      * @param data
@@ -300,7 +342,7 @@ public class ScilabInteger implements ScilabType {
             case sci_uint8:
                 for (int i = 0; i < this.getHeight(); i++) {
                     for (int j = 0; j < this.getWidth(); j++) {
-                        convertedMatrix[i][j] = Long.valueOf(byteData[i][j]);
+                        convertedMatrix[i][j] = Long.valueOf(getByteElement(i, j));
                     }
                 }
                 return convertedMatrix;
@@ -308,7 +350,7 @@ public class ScilabInteger implements ScilabType {
             case sci_uint16:
                 for (int i = 0; i < this.getHeight(); i++) {
                     for (int j = 0; j < this.getWidth(); j++) {
-                        convertedMatrix[i][j] = Long.valueOf(shortData[i][j]);
+                        convertedMatrix[i][j] = Long.valueOf(getShortElement(i, j));
                     }
                 }
                 return convertedMatrix;
@@ -316,7 +358,7 @@ public class ScilabInteger implements ScilabType {
             case sci_uint32:
                 for (int i = 0; i < this.getHeight(); i++) {
                     for (int j = 0; j < this.getWidth(); j++) {
-                        convertedMatrix[i][j] = Long.valueOf(intData[i][j]);
+                        convertedMatrix[i][j] = Long.valueOf(getIntElement(i, j));
                     }
                 }
                 return convertedMatrix;
@@ -429,7 +471,6 @@ public class ScilabInteger implements ScilabType {
             }
         }
         return null;
-
     }
 
     /**
@@ -510,8 +551,12 @@ public class ScilabInteger implements ScilabType {
         }
     }
 
-    // int32(X), int8(x) , int16([x,x,x;x,x,x])
-    // uint32(X), uint8(x) , uint16([x,x,x;x,x,x])
+    /**
+     * {@inheritDoc}
+     */
+    public boolean isReference() {
+        return byref;
+    }
 
     /**
      * @return true, if there is no values; false otherwise.
@@ -554,33 +599,175 @@ public class ScilabInteger implements ScilabType {
     }
 
     /**
+     * Get the byte element at position (i, j)
+     * @param i the row index
+     * @param j the column index
+     * @return a byte
+     */
+    public byte getByteElement(final int i, final int j) {
+        return byteData[i][j];
+    }
+
+    /**
+     * Get the short element at position (i, j)
+     * @param i the row index
+     * @param j the column index
+     * @return a short
+     */
+    public short getShortElement(final int i, final int j) {
+        return shortData[i][j];
+    }
+
+    /**
+     * Get the int element at position (i, j)
+     * @param i the row index
+     * @param j the column index
+     * @return a int
+     */
+    public int getIntElement(final int i, final int j) {
+        return intData[i][j];
+    }
+
+    /**
+     * Get the long element at position (i, j)
+     * @param i the row index
+     * @param j the column index
+     * @return a long
+     */
+    public long getLongElement(final int i, final int j) {
+        return longData[i][j];
+    }
+
+    /**
+     * Set the byte element at position (i, j)
+     * @param i the row index
+     * @param j the column index
+     * @param x the byte to set
+     */
+    public void setByteElement(final int i, final int j, final byte x) {
+        byteData[i][j] = x;
+    }
+
+    /**
+     * Set the short element at position (i, j)
+     * @param i the row index
+     * @param j the column index
+     * @param x the short to set
+     */
+    public void setShortElement(final int i, final int j, final short x) {
+        shortData[i][j] = x;
+    }
+
+    /**
+     * Set the int element at position (i, j)
+     * @param i the row index
+     * @param j the column index
+     * @param x the int to set
+     */
+    public void setIntElement(final int i, final int j, final int x) {
+        intData[i][j] = x;
+    }
+
+    /**
+     * Set the long element at position (i, j)
+     * @param i the row index
+     * @param j the column index
+     * @param x the long to set
+     */
+    public void setLongElement(final int i, final int j, final long x) {
+        longData[i][j] = x;
+    }
+
+
+    /**
+     * Get the element at position (i, j) as a long
+     * @param i the row index
+     * @param j the column index
+     * @return a long
+     */
+    public long getElement(final int i, final int j) {
+        switch (this.getPrec()) {
+            case sci_int8:
+            case sci_uint8:
+                return getByteElement(i, j);
+            case sci_int16:
+            case sci_uint16:
+                return getShortElement(i, j);
+            case sci_int32:
+            case sci_uint32:
+                return getIntElement(i, j);
+            case sci_int64:
+            case sci_uint64:
+                return getLongElement(i, j);
+        }
+
+        return 0;
+    }
+
+    /**
+     * Set the element at position (i, j)
+     * @param i the row index
+     * @param j the column index
+     * @param x a long
+     */
+    public void setElement(final int i, final int j, final long x) {
+        switch (this.getPrec()) {
+            case sci_int8:
+            case sci_uint8:
+                setByteElement(i, j, (byte) x);
+                break;
+            case sci_int16:
+            case sci_uint16:
+                setShortElement(i, j, (short) x);
+                break;
+            case sci_int32:
+            case sci_uint32:
+                setIntElement(i, j, (int) x);
+                break;
+            case sci_int64:
+            case sci_uint64:
+                setLongElement(i, j, x);
+                break;
+        }
+    }
+
+    /**
      * @see org.scilab.modules.types.ScilabType#equals(Object)
      */
     @Override
     public boolean equals(Object obj) {
         if (obj instanceof ScilabInteger) {
-            return Arrays.deepEquals(this.getData(), ((ScilabInteger) obj).getData());
+            ScilabInteger sciInt = (ScilabInteger) obj;
+            if (isEmpty() && sciInt.isEmpty()) {
+                return true;
+            }
+
+            if (this.getWidth() != sciInt.getWidth() || this.getHeight() != sciInt.getHeight()) {
+                return false;
+            }
+
+            return ScilabTypeUtils.equalsInteger(this.getRawData(), this.isSwaped(), sciInt.getRawData(), sciInt.isSwaped());
         } else {
             return false;
         }
     }
 
-    private Object getCorrectData() {
+    /**
+     * Get the data as a array of arrays
+     * @return the data
+     */
+    public Object getCorrectData() {
         switch (this.getPrec()) {
             case sci_int8:
-                return byteData;
             case sci_uint8:
                 return byteData;
             case sci_int16:
-                return shortData;
             case sci_uint16:
                 return shortData;
             case sci_int32:
-                return intData;
             case sci_uint32:
                 return intData;
             case sci_int64:
-                return longData;
             case sci_uint64:
                 return longData;
         }
@@ -588,6 +775,14 @@ public class ScilabInteger implements ScilabType {
     }
 
     /**
+     * Get the data as they are
+     * @return the data
+     */
+    public Object getRawData() {
+        return getCorrectData();
+    }
+
+    /**
      * {@inheritDoc}
      */
     public Object getSerializedObject() {
@@ -648,8 +843,7 @@ public class ScilabInteger implements ScilabType {
         StringBuilder result = new StringBuilder();
 
         if (isEmpty()) {
-            result.append("int([])");
-            return result.toString();
+            return "[]";
         }
 
         if (isUnsigned()) {
@@ -696,10 +890,11 @@ public class ScilabInteger implements ScilabType {
      *            the current buffer
      */
     private void appendData(StringBuilder result) {
+        long[][] d = getData();
         for (int i = 0; i < getHeight(); ++i) {
             for (int j = 0; j < getWidth(); ++j) {
 
-                result.append(getData()[i][j]);
+                result.append(d[i][j]);
 
                 if (j != getWidth() - 1) {
                     result.append(", ");
@@ -710,5 +905,4 @@ public class ScilabInteger implements ScilabType {
             }
         }
     }
-
 }
diff --git a/scilab/modules/types/src/java/org/scilab/modules/types/ScilabIntegerReference.java b/scilab/modules/types/src/java/org/scilab/modules/types/ScilabIntegerReference.java
new file mode 100644 (file)
index 0000000..54d562d
--- /dev/null
@@ -0,0 +1,416 @@
+/*
+ *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ *  Copyright (C) 2009-2009 - DIGITEO - Antoine ELIAS
+ *  Copyright (C) 2011 - DIGITEO - Calixte DENIZET
+ *  Copyright (C) 2013 - Scilab Enterprises - Calixte DENIZET
+ *
+ *  This file must be used under the terms of the CeCILL.
+ *  This source file is licensed as described in the file COPYING, which
+ *  you should have received as part of this distribution.  The terms
+ *  are also available at
+ *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ */
+
+package org.scilab.modules.types;
+
+import java.io.ObjectStreamException;
+import java.nio.ByteBuffer;
+import java.nio.IntBuffer;
+import java.nio.LongBuffer;
+import java.nio.ShortBuffer;
+
+/**
+ * This class provides a representation on the Scilab Integer datatype<br>
+ * <br>
+ * This class is {@link java.io.Serializable} and any modification could impact
+ * load and store of data (Xcos files, Javasci saved data, etc...).<br>
+ * <br>
+ * Example:<br />
+ * <code>
+ * byte [][]a={{32,42,41}, {12,13,32}};<br />
+ * ScilabInteger aMatrix = new ScilabInteger(a, true); // true = unsigned
+ * </code>
+ *
+ * @see org.scilab.modules.javasci.Scilab
+ */
+public class ScilabIntegerReference extends ScilabInteger {
+
+    private LongBuffer longBuffer;
+    private IntBuffer intBuffer;
+    private ShortBuffer shortBuffer;
+    private ByteBuffer byteBuffer;
+    private final int nbRows;
+    private final int nbCols;
+
+    /**
+     * Default constructor
+     */
+    public ScilabIntegerReference() {
+        super();
+        nbRows = 0;
+        nbCols = 0;
+    }
+
+    /**
+     * Constructor with values
+     *
+     * @param data
+     *            the values
+     * @param bUnsigned
+     *            true, if the values are unsigned; false if they are signed.
+     */
+    ScilabIntegerReference(String varName, ByteBuffer data, int nbRows, int nbCols, boolean bUnsigned) {
+        this.varName = varName;
+        this.byteBuffer = data;
+        this.nbRows = nbRows;
+        this.nbCols = nbCols;
+        this.precision = bUnsigned ? ScilabIntegerTypeEnum.sci_uint8 : ScilabIntegerTypeEnum.sci_int8;
+        this.byref = true;
+        this.swaped = false;
+    }
+
+    /**
+     * Constructor with values
+     *
+     * @param data
+     *            the values
+     * @param bUnsigned
+     *            true, if the values are unsigned; false if they are signed.
+     */
+    ScilabIntegerReference(String varName, ShortBuffer data, int nbRows, int nbCols, boolean bUnsigned) {
+        this.varName = varName;
+        this.shortBuffer = data;
+        this.nbRows = nbRows;
+        this.nbCols = nbCols;
+        this.precision = bUnsigned ? ScilabIntegerTypeEnum.sci_uint16 : ScilabIntegerTypeEnum.sci_int16;
+        this.byref = true;
+        this.swaped = false;
+    }
+
+    /**
+     * Constructor with values
+     *
+     * @param data
+     *            the values
+     * @param bUnsigned
+     *            true, if the values are unsigned; false if they are signed.
+     */
+    ScilabIntegerReference(String varName, IntBuffer data, int nbRows, int nbCols, boolean bUnsigned) {
+        this.varName = varName;
+        this.intBuffer = data;
+        this.nbRows = nbRows;
+        this.nbCols = nbCols;
+        this.precision = bUnsigned ? ScilabIntegerTypeEnum.sci_uint32 : ScilabIntegerTypeEnum.sci_int32;
+        this.byref = true;
+        this.swaped = false;
+    }
+
+    /**
+     * Constructor with values
+     *
+     * @param data
+     *            the values
+     * @param bUnsigned
+     *            true, if the values are unsigned; false if they are signed.
+     */
+    ScilabIntegerReference(String varName, LongBuffer data, int nbRows, int nbCols, boolean bUnsigned) {
+        this.varName = varName;
+        this.longBuffer = data;
+        this.nbRows = nbRows;
+        this.nbCols = nbCols;
+        this.precision = bUnsigned ? ScilabIntegerTypeEnum.sci_uint64 : ScilabIntegerTypeEnum.sci_int64;
+        this.byref = true;
+        this.swaped = false;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public byte getByteElement(final int i, final int j) {
+        return byteBuffer.get(i + nbRows * j);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public short getShortElement(final int i, final int j) {
+        return shortBuffer.get(i + nbRows * j);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public int getIntElement(final int i, final int j) {
+        return intBuffer.get(i + nbRows * j);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public long getLongElement(final int i, final int j) {
+        return longBuffer.get(i + nbRows * j);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public void setByteElement(final int i, final int j, final byte x) {
+        byteBuffer.put(i + nbRows * j, x);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public void setShortElement(final int i, final int j, final short x) {
+        shortBuffer.put(i + nbRows * j, x);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public void setIntElement(final int i, final int j, final int x) {
+        intBuffer.put(i + nbRows * j, x);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public void setLongElement(final int i, final int j, final long x) {
+        longBuffer.put(i + nbRows * j, x);
+    }
+
+    /**
+     * Set the current values
+     *
+     * @param data
+     *            the values to set
+     * @param bUnsigned
+     *            true, if these values are unsigned; false otherwise.
+     */
+    public void setData(byte[][] data, boolean bUnsigned) {
+        ScilabTypeUtils.setPart(byteBuffer, data);
+        if (bUnsigned) {
+            this.precision = ScilabIntegerTypeEnum.sci_uint8;
+        } else {
+            this.precision = ScilabIntegerTypeEnum.sci_int8;
+        }
+    }
+
+    /**
+     * Set the current values
+     *
+     * @param data
+     *            the values to set
+     * @param bUnsigned
+     *            true, if these values are unsigned; false otherwise.
+     */
+    public void setData(short[][] data, boolean bUnsigned) {
+        ScilabTypeUtils.setPart(shortBuffer, data);
+        if (bUnsigned) {
+            this.precision = ScilabIntegerTypeEnum.sci_uint16;
+        } else {
+            this.precision = ScilabIntegerTypeEnum.sci_int16;
+        }
+    }
+
+    /**
+     * Set the current values
+     *
+     * @param data
+     *            the values to set
+     * @param bUnsigned
+     *            true, if these values are unsigned; false otherwise.
+     */
+    public void setData(int[][] data, boolean bUnsigned) {
+        ScilabTypeUtils.setPart(intBuffer, data);
+        if (bUnsigned) {
+            this.precision = ScilabIntegerTypeEnum.sci_uint32;
+        } else {
+            this.precision = ScilabIntegerTypeEnum.sci_int32;
+        }
+    }
+
+    /**
+     * Set the current values
+     *
+     * @param data
+     *            the values to set
+     * @param bUnsigned
+     *            true, if these values are unsigned; false otherwise.
+     */
+    public void setData(long[][] data, boolean bUnsigned) {
+        ScilabTypeUtils.setPart(longBuffer, data);
+        if (bUnsigned) {
+            this.precision = ScilabIntegerTypeEnum.sci_uint64;
+        } else {
+            this.precision = ScilabIntegerTypeEnum.sci_int64;
+        }
+    }
+
+    /**
+     * Returns the value as the form of short
+     *
+     * @return the values as short
+     */
+    public short[][] getDataAsShort() {
+        short[][] d = new short[nbRows][nbCols];
+        ScilabTypeUtils.setBuffer(d, shortBuffer);
+
+        return d;
+    }
+
+    /**
+     * Returns the value as the form of byte
+     *
+     * @return the values as byte
+     */
+    public byte[][] getDataAsByte() {
+        byte[][] d = new byte[nbRows][nbCols];
+        ScilabTypeUtils.setBuffer(d, byteBuffer);
+
+        return d;
+    }
+
+    /**
+     * Returns the value as the form of int
+     *
+     * @return the values as int
+     */
+    public int[][] getDataAsInt() {
+        int[][] d = new int[nbRows][nbCols];
+        ScilabTypeUtils.setBuffer(d, intBuffer);
+
+        return d;
+    }
+
+    /**
+     * Returns the value as the form of long Only for Scilab 6.X
+     *
+     * @return the values as long
+     */
+    public long[][] getDataAsLong() {
+        long[][] d = new long[nbRows][nbCols];
+        ScilabTypeUtils.setBuffer(d, longBuffer);
+
+        return d;
+    }
+
+    /**
+     * @return the height of the value matrix
+     * @see org.scilab.modules.types.ScilabType#getHeight()
+     */
+    @Override
+    public int getHeight() {
+        return nbRows;
+    }
+
+    /**
+     * @return the width of the value matrix
+     * @see org.scilab.modules.types.ScilabType#getWidth()
+     */
+    @Override
+    public int getWidth() {
+        return nbCols;
+    }
+
+    /**
+     * @return true, if there is no values; false otherwise.
+     */
+    @Override
+    public boolean isEmpty() {
+        return nbRows == 0 || nbCols == 0;
+    }
+
+    /**
+     * @see org.scilab.modules.types.ScilabType#equals(Object)
+     */
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof ScilabInteger) {
+            ScilabInteger sciInt = (ScilabInteger) obj;
+            if (isEmpty() && sciInt.isEmpty()) {
+                return true;
+            }
+
+            if (this.getWidth() != sciInt.getWidth() || this.getHeight() != sciInt.getHeight()) {
+                return false;
+            }
+
+            return ScilabTypeUtils.equalsInteger(this.getRawData(), this.isSwaped(), sciInt.getRawData(), sciInt.isSwaped());
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public Object getRawData() {
+        switch (this.getPrec()) {
+            case sci_int8:
+            case sci_uint8:
+                return byteBuffer;
+            case sci_int16:
+            case sci_uint16:
+                return shortBuffer;
+            case sci_int32:
+            case sci_uint32:
+                return intBuffer;
+            case sci_int64:
+            case sci_uint64:
+                return longBuffer;
+        }
+
+        return null;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public Object getCorrectData() {
+        switch (this.getPrec()) {
+            case sci_int8:
+            case sci_uint8:
+                return getDataAsByte();
+            case sci_int16:
+            case sci_uint16:
+                return getDataAsShort();
+            case sci_int32:
+            case sci_uint32:
+                return getDataAsInt();
+            case sci_int64:
+            case sci_uint64:
+                return getDataAsLong();
+        }
+
+        return null;
+    }
+
+    /**
+     * When this object is deserialized we want a ScilabInteger, not a ScilabIntegerReference.
+     * @return a ScilabInteger
+     */
+    private Object readResolve() throws ObjectStreamException {
+        switch (precision) {
+            case sci_int8:
+                return new ScilabInteger(varName, byteData, false, swaped);
+            case sci_uint8:
+                return new ScilabInteger(varName, byteData, true, swaped);
+            case sci_int16:
+                return new ScilabInteger(varName, shortData, false, swaped);
+            case sci_uint16:
+                return new ScilabInteger(varName, shortData, true, swaped);
+            case sci_int32:
+                return new ScilabInteger(varName, intData, false, swaped);
+            case sci_uint32:
+                return new ScilabInteger(varName, intData, true, swaped);
+            case sci_int64:
+                return new ScilabInteger(varName, longData, false, swaped);
+            case sci_uint64:
+                return new ScilabInteger(varName, longData, true, swaped);
+        }
+
+        return this;
+    }
+}
index f8a5129..c6bf175 100644 (file)
@@ -73,6 +73,22 @@ public class ScilabList extends ArrayList<ScilabType> implements ScilabType {
     }
 
     /**
+     * @param varName the variable name
+     * @param size the initial list size
+     */
+    public ScilabList(String varName, int size) {
+        super(size);
+        this.varName = varName;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public boolean isReference() {
+        return false;
+    }
+
+    /**
      * {@inheritDoc}
      */
     public String getVarName() {
@@ -182,8 +198,7 @@ public class ScilabList extends ArrayList<ScilabType> implements ScilabType {
     public String toString() {
         StringBuffer result = new StringBuffer();
         if (isEmpty()) {
-            result.append("list()");
-            return result.toString();
+            return "list()";
         }
 
         result.append("list(");
index 0043306..7d67d32 100644 (file)
@@ -100,6 +100,22 @@ public class ScilabMList extends ArrayList<ScilabType> implements ScilabType {
     }
 
     /**
+     * @param varName the variable name
+     * @param size the initial list size
+     */
+    public ScilabMList(String varName, int size) {
+        super(size);
+        this.varName = varName;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public boolean isReference() {
+        return false;
+    }
+
+    /**
      * {@inheritDoc}
      */
     public String getVarName() {
@@ -256,8 +272,7 @@ public class ScilabMList extends ArrayList<ScilabType> implements ScilabType {
 
         StringBuffer result = new StringBuffer();
         if (isEmpty()) {
-            result.append("mlist()");
-            return result.toString();
+            return "mlist()";
         }
 
         result.append("mlist(");
index a7c7d08..dee43a3 100644 (file)
@@ -171,6 +171,13 @@ public class ScilabPolynomial implements ScilabType {
     }
 
     /**
+     * {@inheritDoc}
+     */
+    public boolean isReference() {
+        return false;
+    }
+
+    /**
      * Return the type of Scilab
      *
      * @return the type of Scilab
index 6c8e045..b68abf0 100644 (file)
@@ -36,14 +36,15 @@ public class ScilabSparse implements ScilabType {
 
     private static final int VERSION = 0;
 
-    private int rows;
-    private int cols;
-    private int nbItem;
-    private int[] nbItemRow;
-    private int[] colPos;
-    private double[] realPart;
-    private double[] imaginaryPart;
-    private String varName;
+    protected int rows;
+    protected int cols;
+    protected int nbItem;
+    protected int[] nbItemRow;
+    protected int[] colPos;
+    protected double[] realPart;
+    protected double[] imaginaryPart;
+    protected String varName;
+    protected boolean byref;
 
     /**
      * Default constructor
@@ -356,6 +357,13 @@ public class ScilabSparse implements ScilabType {
     }
 
     /**
+     * {@inheritDoc}
+     */
+    public boolean isReference() {
+        return false;
+    }
+
+    /**
      * Return the type of Scilab
      *
      * @return the type of Scilab
@@ -382,7 +390,232 @@ public class ScilabSparse implements ScilabType {
      * @return true, if the data are real only.
      */
     public boolean isReal() {
-        return (imaginaryPart == null);
+        return imaginaryPart == null;
+    }
+
+    /**
+     * Get the element in column position
+     * @param i the position
+     * @return the column position
+     */
+    public int getColPosElement(final int i) {
+        return colPos[i];
+    }
+
+    /**
+     * Set the element in column position
+     * @param i the position
+     * @param x the column position
+     */
+    public void setColPosElement(final int i, final int x) {
+        colPos[i] = x;
+    }
+
+    /**
+     * Get the number of non-null item in row i
+     * @param i the row
+     * @return the number of non-null items
+     */
+    public int getNbItemElement(final int i) {
+        return nbItemRow[i];
+    }
+
+    /**
+     * Set the number of non-null item in row i
+     * @param i the row
+     * @param x the number of non-null items
+     */
+    public void setNbItemElement(final int i, final int x) {
+        nbItemRow[i] = x;
+    }
+
+    /**
+     * Get the real element at position i
+     * @param i the position
+     * @return a real
+     */
+    public double getRealElement(final int i) {
+        return realPart[i];
+    }
+
+    /**
+     * Get the real element at position (i, j) in the sparse matrix
+     * @param i the row index
+     * @param j the column index
+     * @return a real
+     */
+    public double getRealElement(final int i, final int j) {
+        if (getNbItemElement(i) == 0) {
+            return 0;
+        }
+
+        int prev = 0;
+        for (int k = 0; k < i; k++) {
+            prev += getNbItemElement(k);
+        }
+
+        for (int k = prev; k < prev + getNbItemElement(i); k++) {
+            if (getColPosElement(k) == j) {
+                return getRealElement(k);
+            }
+        }
+
+        return 0;
+    }
+
+    /**
+     * Get the imaginary element at position i
+     * @param i the position
+     * @return a real
+     */
+    public double getImaginaryElement(final int i) {
+        return imaginaryPart[i];
+    }
+
+    /**
+     * Get the imanginary element at position (i, j) in the sparse matrix
+     * @param i the row index
+     * @param j the column index
+     * @return a real
+     */
+    public double getImaginaryElement(final int i, final int j) {
+        if (getNbItemElement(i) == 0) {
+            return 0;
+        }
+
+        int prev = 0;
+        for (int k = 0; k < i; k++) {
+            prev += getNbItemElement(k);
+        }
+
+        for (int k = prev; k < prev + getNbItemElement(i); k++) {
+            if (getColPosElement(k) == j) {
+                return getImaginaryElement(k);
+            }
+        }
+
+        return 0;
+    }
+
+    /**
+     * Get the real and imaginary elements at position i
+     * @param i the position
+     * @return a 2-array containing real and imaginary part
+     */
+    public double[] getElement(final int i) {
+        if (isReal()) {
+            return new double[] {realPart[i], 0};
+        } else {
+            return new double[] {realPart[i], imaginaryPart[i]};
+        }
+    }
+
+    /**
+     * Get the real and imanginary element at position (i, j) in the sparse matrix
+     * @param i the row index
+     * @param j the column index
+     * @return a 2-array containing real and imaginary parts
+     */
+    public double[] getElement(final int i, final int j) {
+        if (isReal()) {
+            return new double[] {getRealElement(i, j), 0};
+        } else {
+            if (getNbItemElement(i) == 0) {
+                return new double[] {0, 0};
+            }
+
+            int prev = 0;
+            for (int k = 0; k < i; k++) {
+                prev += getNbItemElement(k);
+            }
+
+            for (int k = prev; k < prev + getNbItemElement(i); k++) {
+                if (getColPosElement(k) == j) {
+                    return new double[] {getRealElement(k), getImaginaryElement(k)};
+                }
+            }
+
+            return new double[] {0, 0};
+        }
+    }
+
+    /**
+     * Set the real element at position i
+     * @param i the position
+     * @param x the value to set
+     */
+    public void setRealElement(final int i, final double x) {
+        realPart[i] = x;
+    }
+
+    /**
+     * Set the real element at position (i, j) in sparse matrix
+     * Take care only an already non-null element can be set
+     * @param i the row index
+     * @param j the column index
+     * @param x the value to set
+     */
+    public void setRealElement(final int i, final int j, final double x) {
+        if (getNbItemElement(i) == 0) {
+            return;
+        }
+
+        int prev = 0;
+        for (int k = 0; k < i; k++) {
+            prev += getNbItemElement(k);
+        }
+
+        for (int k = prev; k < prev + getNbItemElement(i); k++) {
+            if (getColPosElement(k) == j) {
+                setRealElement(k, x);
+                break;
+            }
+        }
+    }
+
+    /**
+     * Set the imaginary element at position i
+     * @param i the position
+     * @param x the value to set
+     */
+    public void setImaginaryElement(final int i, final double x) {
+        imaginaryPart[i] = x;
+    }
+
+    /**
+     * Set the imaginary element at position (i, j) in sparse matrix
+     * Take care only an already non-null element can be set
+     * @param i the row index
+     * @param j the column index
+     * @param x the value to set
+     */
+    public void setImaginaryElement(final int i, final int j, final double x) {
+        if (getNbItemElement(i) == 0) {
+            return;
+        }
+
+        int prev = 0;
+        for (int k = 0; k < i; k++) {
+            prev += getNbItemElement(k);
+        }
+
+        for (int k = prev; k < prev + getNbItemElement(i); k++) {
+            if (getColPosElement(k) == j) {
+                setImaginaryElement(k, x);
+                break;
+            }
+        }
+    }
+
+    /**
+     * Set the real and imaginary elements at position i
+     * @param i the position
+     * @param x the real part to set
+     * @param y the imaginary part to set
+     */
+    public void setElement(final int i, final double x, final double y) {
+        setRealElement(i, x);
+        setImaginaryElement(i, y);
     }
 
     /**
@@ -602,6 +835,14 @@ public class ScilabSparse implements ScilabType {
     public boolean equals(Object obj) {
         if (obj instanceof ScilabSparse) {
             ScilabSparse sciSparse = (ScilabSparse) obj;
+            if (isEmpty() && sciSparse.isEmpty()) {
+                return true;
+            }
+
+            if (this.getWidth() != sciSparse.getWidth() || this.getHeight() != sciSparse.getHeight()) {
+                return false;
+            }
+
             if (this.getNbNonNullItems() == sciSparse.getNbNonNullItems() && compareNbItemRow(this.getNbItemRow(), sciSparse.getNbItemRow())
                     && Arrays.equals(this.getColPos(), sciSparse.getColPos())) {
                 if (this.isReal() && sciSparse.isReal()) {
@@ -667,9 +908,9 @@ public class ScilabSparse implements ScilabType {
      */
     public Object getSerializedObject() {
         if (isReal()) {
-            return new Object[] { new int[] { getHeight(), getWidth() }, nbItemRow, getScilabColPos(), realPart };
+            return new Object[] { new int[] { getHeight(), getWidth() }, getNbItemRow(), getScilabColPos(), getRealPart() };
         } else {
-            return new Object[] { new int[] { getHeight(), getWidth() }, nbItemRow, getScilabColPos(), realPart, imaginaryPart };
+            return new Object[] { new int[] { getHeight(), getWidth() }, getNbItemRow(), getScilabColPos(), getRealPart(), getImaginaryPart() };
         }
     }
 
@@ -717,13 +958,14 @@ public class ScilabSparse implements ScilabType {
         StringBuilder result = new StringBuilder();
 
         if (isEmpty()) {
-            result.append("[]");
-            return result.toString();
+            return "[]";
         }
 
         result.append("sparse([");
         int j = 0;
         int prev = 0;
+        int[] nbItemRow = getNbItemRow();
+        int[] colPos = getColPos();
         for (int i = 0; i < nbItemRow.length; i++) {
             for (; j < prev + nbItemRow[i]; j++) {
                 result.append(Integer.toString(i + 1));
@@ -737,14 +979,16 @@ public class ScilabSparse implements ScilabType {
         }
 
         result.append("], [");
+        boolean real = isReal();
         for (int i = 0; i < nbItem; i++) {
-            if (isReal()) {
-                result.append(Double.toString(realPart[i]));
-            } else {
-                result.append(Double.toString(realPart[i]));
-                if (imaginaryPart[i] != 0) {
-                    result.append("+");
-                    result.append(Double.toString(imaginaryPart[i]));
+            result.append(Double.toString(getRealElement(i)));
+            if (!real) {
+                final double y = getImaginaryElement(i);
+                if (y != 0) {
+                    if (y > 0) {
+                        result.append("+");
+                    }
+                    result.append(Double.toString(y));
                     result.append("*%i");
                 }
             }
index 53b40ed..8820e75 100644 (file)
@@ -147,6 +147,13 @@ public class ScilabString implements ScilabType {
     }
 
     /**
+     * {@inheritDoc}
+     */
+    public boolean isReference() {
+        return false;
+    }
+
+    /**
      * @return the height of the data matrix
      * @see org.scilab.modules.types.ScilabType#getHeight()
      */
index 8568d29..8686095 100644 (file)
@@ -100,6 +100,22 @@ public class ScilabTList extends ArrayList<ScilabType> implements ScilabType {
     }
 
     /**
+     * @param varName the variable name
+     * @param size the initial list size
+     */
+    public ScilabTList(String varName, int size) {
+        super(size);
+        this.varName = varName;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public boolean isReference() {
+        return false;
+    }
+
+    /**
      * {@inheritDoc}
      */
     public String getVarName() {
@@ -255,8 +271,7 @@ public class ScilabTList extends ArrayList<ScilabType> implements ScilabType {
     public String toString() {
         StringBuffer result = new StringBuffer();
         if (isEmpty()) {
-            result.append("tlist()");
-            return result.toString();
+            return "tlist()";
         }
 
         result.append("tlist(");
index d9553cd..53b5607 100644 (file)
@@ -32,6 +32,11 @@ public interface ScilabType extends Externalizable, Cloneable {
     public ScilabTypeEnum getType();
 
     /**
+     * @return true if data are backed in a java.nio.Buffer
+     */
+    boolean isReference();
+
+    /**
      * Return the width (number of elements) of the stored data
      *
      * @return the width
diff --git a/scilab/modules/types/src/java/org/scilab/modules/types/ScilabTypeUtils.java b/scilab/modules/types/src/java/org/scilab/modules/types/ScilabTypeUtils.java
new file mode 100644 (file)
index 0000000..1597287
--- /dev/null
@@ -0,0 +1,641 @@
+/*
+ * Scilab (http://www.scilab.org/) - This file is part of Scilab
+ * Copyright (C) 2013 - Scilab Enterprises - Calixte DENIZET
+ *
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ */
+
+package org.scilab.modules.types;
+
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.nio.DoubleBuffer;
+import java.nio.ShortBuffer;
+import java.nio.IntBuffer;
+import java.nio.LongBuffer;
+import java.util.Arrays;
+
+/**
+ * This class contains a lot of equals methods.
+ * Unfortunatelly, we cannot template it...
+ */
+final class ScilabTypeUtils {
+
+    /**
+     * Check equality between double data
+     * @param buffer a buffer or matrix
+     * @param bswaped if true the buffer is swaped
+     * @param data a matrix or a buffer
+     * @param dswaped if true the data is swaped
+     * @return true if data contains the same values
+     */
+    static boolean equalsDouble(final Object buffer, final boolean bswaped, final Object data, final boolean dswaped) {
+        if (buffer instanceof DoubleBuffer) {
+            if (data instanceof double[][]) {
+                return equals((DoubleBuffer) buffer, bswaped, (double[][]) data, dswaped);
+            } else {
+                return equals((DoubleBuffer) buffer, bswaped, (DoubleBuffer) data, dswaped);
+            }
+        } else if (buffer instanceof double[][]) {
+            if (data instanceof double[][]) {
+                return equals((double[][]) buffer, bswaped, (double[][]) data, dswaped);
+            } else {
+                return equals((double[][]) buffer, bswaped, (DoubleBuffer) data, dswaped);
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Check equality between integer data
+     * @param buffer a buffer or matrix
+     * @param bswaped if true the buffer is swaped
+     * @param data a matrix or a buffer
+     * @param dswaped if true the data is swaped
+     * @return true if data contains the same values
+     */
+    static boolean equalsInteger(final Object buffer, final boolean bswaped, final Object data, final boolean dswaped) {
+        if (buffer instanceof ByteBuffer) {
+            if (data instanceof byte[][]) {
+                return equals((ByteBuffer) buffer, bswaped, (byte[][]) data, dswaped);
+            } else {
+                return equals((ByteBuffer) buffer, bswaped, (ByteBuffer) data, dswaped);
+            }
+        } else if (buffer instanceof byte[][]) {
+            if (data instanceof byte[][]) {
+                return equals((byte[][]) buffer, bswaped, (byte[][]) data, dswaped);
+            } else {
+                return equals((byte[][]) buffer, bswaped, (ByteBuffer) data, dswaped);
+            }
+        } else if (buffer instanceof ShortBuffer) {
+            if (data instanceof short[][]) {
+                return equals((ShortBuffer) buffer, bswaped, (short[][]) data, dswaped);
+            } else {
+                return equals((ShortBuffer) buffer, bswaped, (ShortBuffer) data, dswaped);
+            }
+        } else if (buffer instanceof short[][]) {
+            if (data instanceof short[][]) {
+                return equals((short[][]) buffer, bswaped, (short[][]) data, dswaped);
+            } else {
+                return equals((short[][]) buffer, bswaped, (ShortBuffer) data, dswaped);
+            }
+        } else if (buffer instanceof IntBuffer) {
+            if (data instanceof int[][]) {
+                return equals((IntBuffer) buffer, bswaped, (int[][]) data, dswaped);
+            } else {
+                return equals((IntBuffer) buffer, bswaped, (IntBuffer) data, dswaped);
+            }
+        } else if (buffer instanceof int[][]) {
+            if (data instanceof int[][]) {
+                return equals((int[][]) buffer, bswaped, (int[][]) data, dswaped);
+            } else {
+                return equals((int[][]) buffer, bswaped, (IntBuffer) data, dswaped);
+            }
+        } else if (buffer instanceof LongBuffer) {
+            if (data instanceof long[][]) {
+                return equals((LongBuffer) buffer, bswaped, (long[][]) data, dswaped);
+            } else {
+                return equals((LongBuffer) buffer, bswaped, (LongBuffer) data, dswaped);
+            }
+        } else if (buffer instanceof long[][]) {
+            if (data instanceof long[][]) {
+                return equals((long[][]) buffer, bswaped, (long[][]) data, dswaped);
+            } else {
+                return equals((long[][]) buffer, bswaped, (LongBuffer) data, dswaped);
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Check equality between boolean data
+     * @param buffer a buffer or matrix
+     * @param bswaped if true the buffer is swaped
+     * @param data a matrix or a buffer
+     * @param dswaped if true the data is swaped
+     * @return true if data contains the same values
+     */
+    static boolean equalsBoolean(final Object buffer, final boolean bswaped, final Object data, final boolean dswaped) {
+        if (buffer instanceof IntBuffer) {
+            if (data instanceof boolean[][]) {
+                return equals((IntBuffer) buffer, bswaped, (boolean[][]) data, dswaped);
+            } else {
+                return equals((IntBuffer) buffer, bswaped, (IntBuffer) data, dswaped);
+            }
+        } else if (buffer instanceof boolean[][]) {
+            if (data instanceof boolean[][]) {
+                return equals((boolean[][]) buffer, bswaped, (boolean[][]) data, dswaped);
+            } else {
+                return equals((boolean[][]) buffer, bswaped, (IntBuffer) data, dswaped);
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Check equality between two buffers
+     * @param buffer a buffer or matrix
+     * @param bswaped if true the buffer is swaped
+     * @param data a matrix or a buffer
+     * @param dswaped if true the data is swaped
+     * @return true if data contains the same values
+     */
+    static boolean equals(final Buffer buffer, final boolean bswaped, final Buffer data, final boolean dswaped) {
+        buffer.clear();
+        data.clear();
+        return buffer.equals(data);
+    }
+
+    /**
+     * Check equality between double data
+     * @param buffer a matrix
+     * @param bswaped if true the buffer is swaped
+     * @param data a buffer
+     * @param dswaped if true the data is swaped
+     * @return true if data contains the same values
+     */
+    static boolean equals(final double[][] buffer, final boolean bswaped, final DoubleBuffer data, final boolean dswaped) {
+        return equals(data, dswaped, buffer, bswaped);
+    }
+
+    /**
+     * Check equality between byte data
+     * @param buffer a matrix
+     * @param bswaped if true the buffer is swaped
+     * @param data a buffer
+     * @param dswaped if true the data is swaped
+     * @return true if data contains the same values
+     */
+    static boolean equals(final byte[][] buffer, final boolean bswaped, final ByteBuffer data, final boolean dswaped) {
+        return equals(data, dswaped, buffer, bswaped);
+    }
+
+    /**
+     * Check equality between short data
+     * @param buffer a matrix
+     * @param bswaped if true the buffer is swaped
+     * @param data a buffer
+     * @param dswaped if true the data is swaped
+     * @return true if data contains the same values
+     */
+    static boolean equals(final short[][] buffer, final boolean bswaped, final ShortBuffer data, final boolean dswaped) {
+        return equals(data, dswaped, buffer, bswaped);
+    }
+
+    /**
+     * Check equality between int data
+     * @param buffer a matrix
+     * @param bswaped if true the buffer is swaped
+     * @param data a buffer
+     * @param dswaped if true the data is swaped
+     * @return true if data contains the same values
+     */
+    static boolean equals(final int[][] buffer, final boolean bswaped, final IntBuffer data, final boolean dswaped) {
+        return equals(data, dswaped, buffer, bswaped);
+    }
+
+    /**
+     * Check equality between long data
+     * @param buffer a matrix
+     * @param bswaped if true the buffer is swaped
+     * @param data a buffer
+     * @param dswaped if true the data is swaped
+     * @return true if data contains the same values
+     */
+    static boolean equals(final long[][] buffer, final boolean bswaped, final LongBuffer data, final boolean dswaped) {
+        return equals(data, dswaped, buffer, bswaped);
+    }
+
+    /**
+     * Check equality between boolean data
+     * @param buffer a matrix
+     * @param bswaped if true the buffer is swaped
+     * @param data a buffer
+     * @param dswaped if true the data is swaped
+     * @return true if data contains the same values
+     */
+    static boolean equals(final boolean[][] buffer, final boolean bswaped, final IntBuffer data, final boolean dswaped) {
+        return equals(data, dswaped, buffer, bswaped);
+    }
+
+    /**
+     * Check equality between matrix data
+     * @param buffer a matrix
+     * @param bswaped if true the buffer is swaped
+     * @param data a matrix
+     * @param dswaped if true the data is swaped
+     * @return true if data contains the same values
+     */
+    static boolean equals(final Object[] buffer, final boolean bswaped, final Object[] data, final boolean dswaped) {
+        return Arrays.deepEquals(buffer, data);
+    }
+
+    /**
+     * Check equality between boolean data
+     * @param buffer a buffer
+     * @param bswaped if true the buffer is swaped
+     * @param data a matrix
+     * @param dswaped if true the data is swaped
+     * @return true if data contains the same values
+     */
+    static boolean equals(final IntBuffer buffer, final boolean bswaped, final boolean[][] data, final boolean dswaped) {
+        final int r = data.length;
+        final int c = r > 0 ? data[0].length : 0;
+        if (!dswaped) {
+            for (int i = 0; i < r; i++) {
+                for (int j = 0; j < c; j++) {
+                    if ((buffer.get(i + r * j) != 0) != data[i][j]) {
+                        return false;
+                    }
+                }
+            }
+        } else {
+            for (int i = 0; i < r; i++) {
+                for (int j = 0; j < c; j++) {
+                    if ((buffer.get(j + c * i) != 0) != data[i][j]) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Check equality between double data
+     * @param buffer a buffer
+     * @param bswaped if true the buffer is swaped
+     * @param data a matrix
+     * @param dswaped if true the data is swaped
+     * @return true if data contains the same values
+     */
+    static boolean equals(final DoubleBuffer buffer, final boolean bswaped, final double[][] data, final boolean dswaped) {
+        if (!dswaped) {
+            final int r = data.length;
+            final int c = r > 0 ? data[0].length : 0;
+            for (int i = 0; i < r; i++) {
+                for (int j = 0; j < c; j++) {
+                    if (buffer.get(i + r * j) != data[i][j]) {
+                        return false;
+                    }
+                }
+            }
+        } else {
+            final int c = data.length;
+            final int r = c > 0 ? data[0].length : 0;
+            buffer.clear();
+            for (int i = 0; i < c; i++) {
+                buffer.position(r * i);
+                buffer.limit(r * i + r);
+                if (!buffer.equals(buffer.wrap(data[i]))) {
+                    buffer.clear();
+                    return false;
+                }
+            }
+            buffer.clear();
+        }
+        return true;
+    }
+
+    /**
+     * Check equality between byte data
+     * @param buffer a buffer
+     * @param bswaped if true the buffer is swaped
+     * @param data a matrix
+     * @param dswaped if true the data is swaped
+     * @return true if data contains the same values
+     */
+    static boolean equals(final ByteBuffer buffer, final boolean bswaped, final byte[][] data, final boolean dswaped) {
+        if (!dswaped) {
+            final int r = data.length;
+            final int c = r > 0 ? data[0].length : 0;
+            for (int i = 0; i < r; i++) {
+                for (int j = 0; j < c; j++) {
+                    if (buffer.get(i + r * j) != data[i][j]) {
+                        return false;
+                    }
+                }
+            }
+        } else {
+            final int c = data.length;
+            final int r = c > 0 ? data[0].length : 0;
+            buffer.clear();
+            for (int i = 0; i < c; i++) {
+                buffer.position(r * i);
+                buffer.limit(r * i + r);
+                if (!buffer.equals(buffer.wrap(data[i]))) {
+                    buffer.clear();
+                    return false;
+                }
+            }
+            buffer.clear();
+        }
+        return true;
+    }
+
+    /**
+     * Check equality between short data
+     * @param buffer a buffer
+     * @param bswaped if true the buffer is swaped
+     * @param data a matrix
+     * @param dswaped if true the data is swaped
+     * @return true if data contains the same values
+     */
+    static boolean equals(final ShortBuffer buffer, final boolean bswaped, final short[][] data, final boolean dswaped) {
+        if (!dswaped) {
+            final int r = data.length;
+            final int c = r > 0 ? data[0].length : 0;
+            for (int i = 0; i < r; i++) {
+                for (int j = 0; j < c; j++) {
+                    if (buffer.get(i + r * j) != data[i][j]) {
+                        return false;
+                    }
+                }
+            }
+        } else {
+            final int c = data.length;
+            final int r = c > 0 ? data[0].length : 0;
+            buffer.clear();
+            for (int i = 0; i < c; i++) {
+                buffer.position(r * i);
+                buffer.limit(r * i + r);
+                if (!buffer.equals(buffer.wrap(data[i]))) {
+                    buffer.clear();
+                    return false;
+                }
+            }
+            buffer.clear();
+        }
+        return true;
+    }
+
+    /**
+     * Check equality between int data
+     * @param buffer a buffer
+     * @param bswaped if true the buffer is swaped
+     * @param data a matrix
+     * @param dswaped if true the data is swaped
+     * @return true if data contains the same values
+     */
+    static boolean equals(final IntBuffer buffer, final boolean bswaped, final int[][] data, final boolean dswaped) {
+        if (!dswaped) {
+            final int r = data.length;
+            final int c = r > 0 ? data[0].length : 0;
+            for (int i = 0; i < r; i++) {
+                for (int j = 0; j < c; j++) {
+                    if (buffer.get(i + r * j) != data[i][j]) {
+                        return false;
+                    }
+                }
+            }
+        } else {
+            final int c = data.length;
+            final int r = c > 0 ? data[0].length : 0;
+            buffer.clear();
+            for (int i = 0; i < c; i++) {
+                buffer.position(r * i);
+                buffer.limit(r * i + r);
+                if (!buffer.equals(buffer.wrap(data[i]))) {
+                    buffer.clear();
+                    return false;
+                }
+            }
+            buffer.clear();
+        }
+        return true;
+    }
+
+    /**
+     * Check equality between long data
+     * @param buffer a buffer
+     * @param bswaped if true the buffer is swaped
+     * @param data a matrix
+     * @param dswaped if true the data is swaped
+     * @return true if data contains the same values
+     */
+    static final boolean equals(final LongBuffer buffer, final boolean bswaped, final long[][] data, final boolean dswaped) {
+        if (!dswaped) {
+            final int r = data.length;
+            final int c = r > 0 ? data[0].length : 0;
+            for (int i = 0; i < r; i++) {
+                for (int j = 0; j < c; j++) {
+                    if (buffer.get(i + r * j) != data[i][j]) {
+                        return false;
+                    }
+                }
+            }
+        } else {
+            final int c = data.length;
+            final int r = c > 0 ? data[0].length : 0;
+            buffer.clear();
+            for (int i = 0; i < c; i++) {
+                buffer.position(r * i);
+                buffer.limit(r * i + r);
+                if (!buffer.equals(buffer.wrap(data[i]))) {
+                    buffer.clear();
+                    return false;
+                }
+            }
+            buffer.clear();
+        }
+        return true;
+    }
+
+    /**
+     * Set the real part of the data.
+     *
+     * @param realPart
+     *            the real part.
+     */
+    public static final void setBuffer(final double[][] part, final DoubleBuffer buffer) {
+        final int c = part.length;
+        final int r = c > 0 ? part[0].length : 0;
+        if (r * c <= buffer.capacity()) {
+            buffer.clear();
+            for (int i = 0; i < c; i++) {
+                buffer.get(part[i]);
+            }
+        }
+    }
+
+    /**
+     * Set the part of the data.
+     */
+    public static final void setPart(final DoubleBuffer buffer, final double[][] part) {
+        final int c = part.length;
+        final int r = c > 0 ? part[0].length : 0;
+        if (r * c <= buffer.capacity()) {
+            buffer.clear();
+            for (int i = 0; i < c; i++) {
+                buffer.put(part[i]);
+            }
+        }
+    }
+
+    /**
+     * Set the real part of the data.
+     *
+     * @param realPart
+     *            the real part.
+     */
+    public static final void setBuffer(final byte[][] part, final ByteBuffer buffer) {
+        final int c = part.length;
+        final int r = c > 0 ? part[0].length : 0;
+        if (r * c <= buffer.capacity()) {
+            buffer.clear();
+            for (int i = 0; i < c; i++) {
+                buffer.get(part[i]);
+            }
+        }
+    }
+
+    /**
+     * Set the part of the data.
+     */
+    public static final void setPart(final ByteBuffer buffer, final byte[][] part) {
+        final int c = part.length;
+        final int r = c > 0 ? part[0].length : 0;
+        if (r * c <= buffer.capacity()) {
+            buffer.clear();
+            for (int i = 0; i < c; i++) {
+                buffer.put(part[i]);
+            }
+        }
+    }
+
+    /**
+     * Set the real part of the data.
+     *
+     * @param realPart
+     *            the real part.
+     */
+    public static final void setBuffer(final short[][] part, final ShortBuffer buffer) {
+        final int c = part.length;
+        final int r = c > 0 ? part[0].length : 0;
+        if (r * c <= buffer.capacity()) {
+            buffer.clear();
+            for (int i = 0; i < c; i++) {
+                buffer.get(part[i]);
+            }
+        }
+    }
+
+    /**
+     * Set the part of the data.
+     */
+    public static final void setPart(final ShortBuffer buffer, final short[][] part) {
+        final int c = part.length;
+        final int r = c > 0 ? part[0].length : 0;
+        if (r * c <= buffer.capacity()) {
+            buffer.clear();
+            for (int i = 0; i < c; i++) {
+                buffer.put(part[i]);
+            }
+        }
+    }
+
+    /**
+     * Set the real part of the data.
+     *
+     * @param realPart
+     *            the real part.
+     */
+    public static final void setBuffer(final int[][] part, final IntBuffer buffer) {
+        final int c = part.length;
+        final int r = c > 0 ? part[0].length : 0;
+        if (r * c <= buffer.capacity()) {
+            buffer.clear();
+            for (int i = 0; i < c; i++) {
+                buffer.get(part[i]);
+            }
+        }
+    }
+
+    /**
+     * Set the part of the data.
+     */
+    public static final void setPart(final IntBuffer buffer, final int[][] part) {
+        final int c = part.length;
+        final int r = c > 0 ? part[0].length : 0;
+        if (r * c <= buffer.capacity()) {
+            buffer.clear();
+            for (int i = 0; i < c; i++) {
+                buffer.put(part[i]);
+            }
+        }
+    }
+
+    /**
+     * Set the real part of the data.
+     *
+     * @param realPart
+     *            the real part.
+     */
+    public static final void setBuffer(final long[][] part, final LongBuffer buffer) {
+        final int c = part.length;
+        final int r = c > 0 ? part[0].length : 0;
+        if (r * c <= buffer.capacity()) {
+            buffer.clear();
+            for (int i = 0; i < c; i++) {
+                buffer.get(part[i]);
+            }
+        }
+    }
+
+    /**
+     * Set the part of the data.
+     */
+    public static final void setPart(final LongBuffer buffer, final long[][] part) {
+        final int c = part.length;
+        final int r = c > 0 ? part[0].length : 0;
+        if (r * c <= buffer.capacity()) {
+            buffer.clear();
+            for (int i = 0; i < c; i++) {
+                buffer.put(part[i]);
+            }
+        }
+    }
+
+    /**
+     * Set the part of the data.
+     */
+    public static final void setPart(final IntBuffer buffer, final boolean[][] part) {
+        final int c = part.length;
+        final int r = c > 0 ? part[0].length : 0;
+        if (r * c == buffer.capacity()) {
+            buffer.clear();
+            for (int i = 0; i < c; i++) {
+                for (int j = 0; j < r; j++) {
+                    buffer.put(i + c * j, part[i][j] ? 1 : 0);
+                }
+            }
+        }
+    }
+
+    /**
+     * Set the real part of the data.
+     *
+     * @param realPart
+     *            the real part.
+     */
+    public static final void setBuffer(final boolean[][] part, final IntBuffer buffer) {
+        final int c = part.length;
+        final int r = c > 0 ? part[0].length : 0;
+        if (r * c <= buffer.capacity()) {
+            buffer.clear();
+            for (int i = 0; i < c; i++) {
+                for (int j = 0; j < r; j++) {
+                    part[i][j] = buffer.get(i + c * j) != 0;
+                }
+            }
+        }
+    }
+}
index dc60ff2..281f818 100644 (file)
@@ -1,6 +1,7 @@
 /*
  * Scilab (http://www.scilab.org/) - This file is part of Scilab
  * Copyright (C) 2011 - DIGITEO - Calixte DENIZET
+ * Copyright (C) 2013 - Scilab Enterprises - Calixte DENIZET
  *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
 
 package org.scilab.modules.types;
 
+import java.nio.ByteBuffer;
+import java.nio.DoubleBuffer;
+import java.nio.IntBuffer;
+import java.nio.LongBuffer;
+import java.nio.ShortBuffer;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.HashMap;
@@ -111,6 +117,29 @@ public final class ScilabVariables {
     }
 
     /**
+     * Send double matrix as DoubleBuffer
+     *
+     * @param varName
+     *            the variable name
+     * @param indexes
+     *            an integer array with the indexes of the (sub)*-list which
+     *            will contain the data
+     * @param data
+     *            the data
+     * @param swaped
+     *            true if the matrix is stored row by row
+     * @param handlerId
+     *            the handler id
+     */
+    public static final void sendDataAsBuffer(String varName, int[] indexes, DoubleBuffer data, int rows, int cols, int handlerId) {
+        if (indexes.length != 0) {
+            addElement(indexes, new ScilabDoubleReference(null, data, null, rows, cols));
+        } else {
+            handlers.get(handlerId).handle(new ScilabDoubleReference(varName, data, null, rows, cols));
+        }
+    }
+
+    /**
      * Send complex matrix
      *
      * @param varName
@@ -136,6 +165,29 @@ public final class ScilabVariables {
     }
 
     /**
+     * Send complex matrix as DoubleBuffer
+     *
+     * @param varName
+     *            the variable name
+     * @param indexes
+     *            an integer array with the indexes of the (sub)*-list which
+     *            will contain the data
+     * @param data
+     *            the data
+     * @param swaped
+     *            true if the matrix is stored row by row
+     * @param handlerId
+     *            the handler id
+     */
+    public static final void sendDataAsBuffer(String varName, int[] indexes, DoubleBuffer real, DoubleBuffer imag, int rows, int cols, int handlerId) {
+        if (indexes.length != 0) {
+            addElement(indexes, new ScilabDoubleReference(null, real, imag, rows, cols));
+        } else {
+            handlers.get(handlerId).handle(new ScilabDoubleReference(varName, real, imag, rows, cols));
+        }
+    }
+
+    /**
      * Send int32 matrix
      *
      * @param varName
@@ -159,6 +211,29 @@ public final class ScilabVariables {
     }
 
     /**
+     * Send int32 matrix as IntBuffer
+     *
+     * @param varName
+     *            the variable name
+     * @param indexes
+     *            an integer array with the indexes of the (sub)*-list which
+     *            will contain the data
+     * @param data
+     *            the data
+     * @param swaped
+     *            true if the matrix is stored row by row
+     * @param handlerId
+     *            the handler id
+     */
+    public static final void sendDataAsBuffer(String varName, int[] indexes, IntBuffer data, int rows, int cols, int handlerId) {
+        if (indexes.length != 0) {
+            addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, false));
+        } else {
+            handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, false));
+        }
+    }
+
+    /**
      * Send uint16 matrix
      *
      * @param varName
@@ -182,6 +257,29 @@ public final class ScilabVariables {
     }
 
     /**
+     * Send uint16 matrix as ShortBuffer
+     *
+     * @param varName
+     *            the variable name
+     * @param indexes
+     *            an integer array with the indexes of the (sub)*-list which
+     *            will contain the data
+     * @param data
+     *            the data
+     * @param swaped
+     *            true if the matrix is stored row by row
+     * @param handlerId
+     *            the handler id
+     */
+    public static final void sendUnsignedDataAsBuffer(String varName, int[] indexes, ShortBuffer data, int rows, int cols, int handlerId) {
+        if (indexes.length != 0) {
+            addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, true));
+        } else {
+            handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, true));
+        }
+    }
+
+    /**
      * Send int16 matrix
      *
      * @param varName
@@ -205,6 +303,29 @@ public final class ScilabVariables {
     }
 
     /**
+     * Send int16 matrix as ShortBuffer
+     *
+     * @param varName
+     *            the variable name
+     * @param indexes
+     *            an integer array with the indexes of the (sub)*-list which
+     *            will contain the data
+     * @param data
+     *            the data
+     * @param swaped
+     *            true if the matrix is stored row by row
+     * @param handlerId
+     *            the handler id
+     */
+    public static final void sendDataAsBuffer(String varName, int[] indexes, ShortBuffer data, int rows, int cols, int handlerId) {
+        if (indexes.length != 0) {
+            addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, false));
+        } else {
+            handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, false));
+        }
+    }
+
+    /**
      * Send uint8 matrix
      *
      * @param varName
@@ -228,6 +349,29 @@ public final class ScilabVariables {
     }
 
     /**
+     * Send uint8 matrix as ByteBuffer
+     *
+     * @param varName
+     *            the variable name
+     * @param indexes
+     *            an integer array with the indexes of the (sub)*-list which
+     *            will contain the data
+     * @param data
+     *            the data
+     * @param swaped
+     *            true if the matrix is stored row by row
+     * @param handlerId
+     *            the handler id
+     */
+    public static final void sendUnsignedDataAsBuffer(String varName, int[] indexes, ByteBuffer data, int rows, int cols, int handlerId) {
+        if (indexes.length != 0) {
+            addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, true));
+        } else {
+            handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, true));
+        }
+    }
+
+    /**
      * Send boolean matrix
      *
      * @param varName
@@ -251,6 +395,29 @@ public final class ScilabVariables {
     }
 
     /**
+     * Send boolean matrix as reference
+     *
+     * @param varName
+     *            the variable name
+     * @param indexes
+     *            an integer array with the indexes of the (sub)*-list which
+     *            will contain the data
+     * @param data
+     *            the data
+     * @param swaped
+     *            true if the matrix is stored row by row
+     * @param handlerId
+     *            the handler id
+     */
+    public static final void sendBooleanDataAsBuffer(String varName, int[] indexes, IntBuffer data, int rows, int cols, int handlerId) {
+        if (indexes.length != 0) {
+            addElement(indexes, new ScilabBooleanReference(null, data, rows, cols));
+        } else {
+            handlers.get(handlerId).handle(new ScilabBooleanReference(varName, data, rows, cols));
+        }
+    }
+
+    /**
      * Send int8 matrix
      *
      * @param varName
@@ -274,6 +441,29 @@ public final class ScilabVariables {
     }
 
     /**
+     * Send int8 matrix as ByteBuffer
+     *
+     * @param varName
+     *            the variable name
+     * @param indexes
+     *            an integer array with the indexes of the (sub)*-list which
+     *            will contain the data
+     * @param data
+     *            the data
+     * @param swaped
+     *            true if the matrix is stored row by row
+     * @param handlerId
+     *            the handler id
+     */
+    public static final void sendDataAsBuffer(String varName, int[] indexes, ByteBuffer data, int rows, int cols, int handlerId) {
+        if (indexes.length != 0) {
+            addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, false));
+        } else {
+            handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, false));
+        }
+    }
+
+    /**
      * Send int64 or uint64 matrix
      *
      * @param varName
@@ -297,6 +487,29 @@ public final class ScilabVariables {
     }
 
     /**
+     * Send int64 or uint64 matrix as LongBuffer
+     *
+     * @param varName
+     *            the variable name
+     * @param indexes
+     *            an integer array with the indexes of the (sub)*-list which
+     *            will contain the data
+     * @param data
+     *            the data
+     * @param swaped
+     *            true if the matrix is stored row by row
+     * @param handlerId
+     *            the handler id
+     */
+    public static final void sendDataAsBuffer(String varName, int[] indexes, LongBuffer data, int rows, int cols, int handlerId) {
+        if (indexes.length != 0) {
+            addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, false));
+        } else {
+            handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, false));
+        }
+    }
+
+    /**
      * Send uint32 matrix
      *
      * @param varName
@@ -320,6 +533,29 @@ public final class ScilabVariables {
     }
 
     /**
+     * Send uint32 matrix as IntBuffer
+     *
+     * @param varName
+     *            the variable name
+     * @param indexes
+     *            an integer array with the indexes of the (sub)*-list which
+     *            will contain the data
+     * @param data
+     *            the data
+     * @param swaped
+     *            true if the matrix is stored row by row
+     * @param handlerId
+     *            the handler id
+     */
+    public static final void sendUnsignedDataAsBuffer(String varName, int[] indexes, IntBuffer data, int rows, int cols, int handlerId) {
+        if (indexes.length != 0) {
+            addElement(indexes, new ScilabIntegerReference(null, data, rows, cols, true));
+        } else {
+            handlers.get(handlerId).handle(new ScilabIntegerReference(varName, data, rows, cols, true));
+        }
+    }
+
+    /**
      * Send string matrix
      *
      * @param varName
@@ -374,7 +610,39 @@ public final class ScilabVariables {
     }
 
     /**
-     * Send double sparse matrix
+     * Send double sparse matrix as buffer
+     * Useless for now due to Scilab limitations (A=sparse(...);A(1,1)=123; a new A is created so references are lost)
+     *
+     * @param varName
+     *            the variable name
+     * @param indexes
+     *            an integer array with the indexes of the (sub)*-list which
+     *            will contain the data
+     * @param row
+     *            the row number
+     * @param col
+     *            the col number
+     * @param nbItem
+     *            the number of non null elements
+     * @param nbItemRow
+     *            the number by row of non null elements
+     * @param colPos
+     *            the column position of the non null elements
+     * @param data
+     *            the data
+     * @param handlerId
+     *            the handler id
+     */
+    /*public static final void sendDataAsBuffer(String varName, int[] indexes, int row, int col, int nbItem, IntBuffer nbItemRow, IntBuffer colPos, DoubleBuffer data, int handlerId) {
+      if (indexes.length != 0) {
+      addElement(indexes, new ScilabSparseReference(null, row, col, nbItem, nbItemRow, colPos, data, null));
+      } else {
+      handlers.get(handlerId).handle(new ScilabSparseReference(varName, row, col, nbItem, nbItemRow, colPos, data, null));
+      }
+      }*/
+
+    /**
+     * Send complex sparse matrix
      *
      * @param varName
      *            the variable name
@@ -398,8 +666,7 @@ public final class ScilabVariables {
      * @param handlerId
      *            the handler id
      */
-    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) {
+    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) {
         if (indexes.length != 0) {
             addElement(indexes, new ScilabSparse(null, row, col, nbItem, nbItemRow, colPos, real, imag));
         } else {
@@ -408,7 +675,42 @@ public final class ScilabVariables {
     }
 
     /**
+     * Send complex sparse matrix as buffer
+     * Useless for now due to Scilab limitations (A=sparse(...);A(1,1)=123; a new A is created so references are lost)
+     *
+     * @param varName
+     *            the variable name
+     * @param indexes
+     *            an integer array with the indexes of the (sub)*-list which
+     *            will contain the data
+     * @param row
+     *            the row number
+     * @param col
+     *            the col number
+     * @param nbItem
+     *            the number of non null elements
+     * @param nbItemRow
+     *            the number by row of non null elements
+     * @param colPos
+     *            the column position of the non null elements
+     * @param real
+     *            the real data
+     * @param imag
+     *            the imaginary data
+     * @param handlerId
+     *            the handler id
+     */
+    /*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) {
+      if (indexes.length != 0) {
+      addElement(indexes, new ScilabSparse(null, row, col, nbItem, nbItemRow, colPos, real, imag));
+      } else {
+      handlers.get(handlerId).handle(new ScilabSparse(varName, row, col, nbItem, nbItemRow, colPos, real, imag));
+      }
+      }*/
+
+    /**
      * Send boolean sparse matrix
+     * Useless for now due to Scilab limitations (A=sparse(...);A(1,1)=123; a new A is created so references are lost)
      *
      * @param varName
      *            the variable name
@@ -428,7 +730,7 @@ public final class ScilabVariables {
      * @param handlerId
      *            the handler id
      */
-    public static final void sendData(String varName, int[] indexes, int row, int col, int nbItem, int[] nbItemRow, int[] colPos, int handlerId) {
+    private static final void sendData(String varName, int[] indexes, int row, int col, int nbItem, int[] nbItemRow, int[] colPos, int handlerId) {
         if (indexes.length != 0) {
             addElement(indexes, new ScilabBooleanSparse(null, row, col, nbItem, nbItemRow, colPos));
         } else {
@@ -437,6 +739,35 @@ public final class ScilabVariables {
     }
 
     /**
+     * Send boolean sparse matrix as Buffer
+     *
+     * @param varName
+     *            the variable name
+     * @param indexes
+     *            an integer array with the indexes of the (sub)*-list which
+     *            will contain the data
+     * @param row
+     *            the row number
+     * @param col
+     *            the col number
+     * @param nbItem
+     *            the number of true elements
+     * @param nbItemRow
+     *            the number by row of true elements
+     * @param colPos
+     *            the column position of the true elements
+     * @param handlerId
+     *            the handler id
+     */
+    /*public static final void sendDataAsBuffer(String varName, int[] indexes, int row, int col, int nbItem, IntBuffer nbItemRow, IntBuffer colPos, int handlerId) {
+      if (indexes.length != 0) {
+      addElement(indexes, new ScilabBooleanSparse(null, row, col, nbItem, nbItemRow, colPos));
+      } else {
+      handlers.get(handlerId).handle(new ScilabBooleanSparse(varName, row, col, nbItem, nbItemRow, colPos));
+      }
+      }*/
+
+    /**
      * Send double polynomial matrix
      *
      * @param varName
@@ -503,7 +834,7 @@ public final class ScilabVariables {
      * @param handlerId
      *            the handler id
      */
-    public static final void sendData(String varName, int[] indexes, char type, int handlerId) {
+    public static final void sendData(String varName, int nbItems, int[] indexes, char type, int handlerId) {
         String name = null;
         if (indexes.length == 0) {
             name = varName;
@@ -512,13 +843,13 @@ public final class ScilabVariables {
         ScilabType var = null;
         switch (type) {
             case 'l':
-                var = new ScilabList(name);
+                var = new ScilabList(name, nbItems);
                 break;
             case 'm':
-                var = new ScilabMList(name);
+                var = new ScilabMList(name, nbItems);
                 break;
             case 't':
-                var = new ScilabTList(name);
+                var = new ScilabTList(name, nbItems);
                 break;
         }
 
index af702e8..d333a1e 100644 (file)
@@ -1,6 +1,6 @@
 #include "ScilabVariables.hxx"
 /* Generated by GIWS (version 2.0.1) with command:
-giws --disable-return-size-array --output-dir src/jni/ --throws-exception-on-error --description-file src/jni/ScilabVariables.giws.xml 
+giws -e -r -f ScilabVariables.giws.xml
 */
 /*
 
@@ -10,16 +10,16 @@ This software is a computer program whose purpose is to hide the complexity
 of accessing Java objects/methods from C++ code.
 
 This software is governed by the CeCILL-B license under French law and
-abiding by the rules of distribution of free software.  You can  use, 
+abiding by the rules of distribution of free software.  You can  use,
 modify and/ or redistribute the software under the terms of the CeCILL-B
 license as circulated by CEA, CNRS and INRIA at the following URL
-"http://www.cecill.info". 
+"http://www.cecill.info".
 
 As a counterpart to the access to the source code and  rights to copy,
 modify and redistribute granted by the license, users are provided only
 with a limited warranty  and the software's author,  the holder of the
 economic rights,  and the successive licensors  have only  limited
-liability. 
+liability.
 
 In this respect, the user's attention is drawn to the risks associated
 with loading,  using,  modifying and/or developing or reproducing the
@@ -28,1215 +28,3519 @@ that may mean  that it is complicated to manipulate,  and  that  also
 therefore means  that it is reserved for developers  and  experienced
 professionals having in-depth computer knowledge. Users are therefore
 encouraged to load and test the software's suitability as regards their
-requirements in conditions enabling the security of their systems and/or 
-data to be ensured and,  more generally, to use and operate it in the 
-same conditions as regards security. 
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
 
 The fact that you are presently reading this means that you have had
 knowledge of the CeCILL-B license and that you accept its terms.
 */
 
-namespace org_scilab_modules_types {
+namespace org_scilab_modules_types
+{
 
-                // Static declarations (if any)
-                
+// Static declarations (if any)
+
+// Cache of the bytebuffer stuff
+jclass ScilabVariables::ByteOrderClass = NULL;
+jmethodID ScilabVariables::nativeOrderID = NULL;
+jobject ScilabVariables::nativeOrder = NULL;
+jmethodID ScilabVariables::orderID = NULL;
+jclass ScilabVariables::bbCls = NULL;
+jmethodID ScilabVariables::asdbIDByteBuffer = NULL;
+jmethodID ScilabVariables::asdbIDCharBuffer = NULL;
+jmethodID ScilabVariables::asdbIDDoubleBuffer = NULL;
+jmethodID ScilabVariables::asdbIDFloatBuffer = NULL;
+jmethodID ScilabVariables::asdbIDIntBuffer = NULL;
+jmethodID ScilabVariables::asdbIDLongBuffer = NULL;
+jmethodID ScilabVariables::asdbIDShortBuffer = NULL;
 // Returns the current env
 
-JNIEnv * ScilabVariables::getCurrentEnv() {
-JNIEnv * curEnv = NULL;
-jint res=this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-if (res != JNI_OK) {
-throw GiwsException::JniException(getCurrentEnv());
-}
-return curEnv;
+JNIEnv * ScilabVariables::getCurrentEnv()
+{
+    JNIEnv * curEnv = NULL;
+    jint res = this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    if (res != JNI_OK)
+    {
+        throw GiwsException::JniException(getCurrentEnv());
+    }
+    return curEnv;
 }
 // Destructor
 
-ScilabVariables::~ScilabVariables() {
-JNIEnv * curEnv = NULL;
-this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-
-curEnv->DeleteGlobalRef(this->instance);
-curEnv->DeleteGlobalRef(this->instanceClass);
-curEnv->DeleteGlobalRef(this->stringArrayClass);}
-// Constructors
-ScilabVariables::ScilabVariables(JavaVM * jvm_) {
-jmethodID constructObject = NULL ;
-jobject localInstance ;
-jclass localClass ;
-
-const std::string construct="<init>";
-const std::string param="()V";
-jvm=jvm_;
-
-JNIEnv * curEnv = getCurrentEnv();
-
-localClass = curEnv->FindClass( this->className().c_str() ) ;
-if (localClass == NULL) {
-  throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+ScilabVariables::~ScilabVariables()
+{
+    JNIEnv * curEnv = NULL;
+    this->jvm->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    curEnv->DeleteGlobalRef(this->instance);
+    curEnv->DeleteGlobalRef(this->instanceClass);
+    curEnv->DeleteGlobalRef(this->stringArrayClass);
 }
+// Constructors
+ScilabVariables::ScilabVariables(JavaVM * jvm_)
+{
+    jmethodID constructObject = NULL ;
+    jobject localInstance ;
+    jclass localClass ;
+
+    const std::string construct = "<init>";
+    const std::string param = "()V";
+    jvm = jvm_;
+
+    JNIEnv * curEnv = getCurrentEnv();
+
+    localClass = curEnv->FindClass( this->className().c_str() ) ;
+    if (localClass == NULL)
+    {
+        throw GiwsException::JniClassNotFoundException(curEnv, this->className());
+    }
+
+    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+
+    /* localClass is not needed anymore */
+    curEnv->DeleteLocalRef(localClass);
+
+    if (this->instanceClass == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
+
+
+    constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
+    if (constructObject == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
+
+    localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
+    if (localInstance == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
+
+    this->instance = curEnv->NewGlobalRef(localInstance) ;
+    if (this->instance == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
+    /* localInstance not needed anymore */
+    curEnv->DeleteLocalRef(localInstance);
+
+    /* Methods ID set to NULL */
+    jobjectArray_getAllListenedVariablesID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejbooleanbooleanjintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjintintjintintjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejobjectArray__doubledoublejbooleanbooleanjintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjintintjintintjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID = NULL;
+    voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ByteBufferjava_lang_ByteBufferjintintjintintjintintID = NULL;
+    voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ByteBufferjava_lang_ByteBufferjintintjintintjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID = NULL;
+    voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ShortBufferjava_lang_ShortBufferjintintjintintjintintID = NULL;
+    voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ShortBufferjava_lang_ShortBufferjintintjintintjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID = NULL;
+    voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_IntBufferjava_lang_IntBufferjintintjintintjintintID = NULL;
+    voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_IntBufferjava_lang_IntBufferjintintjintintjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__longlongjbooleanbooleanjintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_LongBufferjava_lang_LongBufferjintintjintintjintintID = NULL;
+    voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_LongBufferjava_lang_LongBufferjintintjintintjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__booleanbooleanjbooleanbooleanjintintID = NULL;
+    voidsendBooleanDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_IntBufferjava_lang_IntBufferjintintjintintjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__java_lang_Stringjava_lang_StringjbooleanbooleanjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintintjintArray_intintjcharcharjintintID = NULL;
+    voidcloseListjintArray_intintjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjintintjintintjintintjobject_java_lang_IntBufferjava_lang_IntBufferjobject_java_lang_IntBufferjava_lang_IntBufferjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjintintjintintjintintjobject_java_lang_IntBufferjava_lang_IntBufferjobject_java_lang_IntBufferjava_lang_IntBufferjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjintintjintintjintintjobject_java_lang_IntBufferjava_lang_IntBufferjobject_java_lang_IntBufferjava_lang_IntBufferjintintID = NULL;
+
+
+}
+
+ScilabVariables::ScilabVariables(JavaVM * jvm_, jobject JObj)
+{
+    jvm = jvm_;
+
+    JNIEnv * curEnv = getCurrentEnv();
+
+    jclass localClass = curEnv->GetObjectClass(JObj);
+    this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
+    curEnv->DeleteLocalRef(localClass);
+
+    if (this->instanceClass == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
+
+    this->instance = curEnv->NewGlobalRef(JObj) ;
+    if (this->instance == NULL)
+    {
+        throw GiwsException::JniObjectCreationException(curEnv, this->className());
+    }
+    /* Methods ID set to NULL */
+    jobjectArray_getAllListenedVariablesID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejbooleanbooleanjintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjintintjintintjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejobjectArray__doubledoublejbooleanbooleanjintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjintintjintintjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID = NULL;
+    voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ByteBufferjava_lang_ByteBufferjintintjintintjintintID = NULL;
+    voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ByteBufferjava_lang_ByteBufferjintintjintintjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID = NULL;
+    voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ShortBufferjava_lang_ShortBufferjintintjintintjintintID = NULL;
+    voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ShortBufferjava_lang_ShortBufferjintintjintintjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID = NULL;
+    voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_IntBufferjava_lang_IntBufferjintintjintintjintintID = NULL;
+    voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_IntBufferjava_lang_IntBufferjintintjintintjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__longlongjbooleanbooleanjintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_LongBufferjava_lang_LongBufferjintintjintintjintintID = NULL;
+    voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_LongBufferjava_lang_LongBufferjintintjintintjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__booleanbooleanjbooleanbooleanjintintID = NULL;
+    voidsendBooleanDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_IntBufferjava_lang_IntBufferjintintjintintjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__java_lang_Stringjava_lang_StringjbooleanbooleanjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintintjintArray_intintjcharcharjintintID = NULL;
+    voidcloseListjintArray_intintjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjintintjintintjintintjobject_java_lang_IntBufferjava_lang_IntBufferjobject_java_lang_IntBufferjava_lang_IntBufferjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjintintjintintjintintjobject_java_lang_IntBufferjava_lang_IntBufferjobject_java_lang_IntBufferjava_lang_IntBufferjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjintintID = NULL;
+    voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjintintID = NULL;
+    voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjintintjintintjintintjobject_java_lang_IntBufferjava_lang_IntBufferjobject_java_lang_IntBufferjava_lang_IntBufferjintintID = NULL;
 
-this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
-
-/* localClass is not needed anymore */
-curEnv->DeleteLocalRef(localClass);
 
-if (this->instanceClass == NULL) {
-throw GiwsException::JniObjectCreationException(curEnv, this->className());
 }
 
+// Generic methods
 
-constructObject = curEnv->GetMethodID( this->instanceClass, construct.c_str() , param.c_str() ) ;
-if(constructObject == NULL){
-throw GiwsException::JniObjectCreationException(curEnv, this->className());
+void ScilabVariables::synchronize()
+{
+    if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabVariables");
+    }
 }
 
-localInstance = curEnv->NewObject( this->instanceClass, constructObject ) ;
-if(localInstance == NULL){
-throw GiwsException::JniObjectCreationException(curEnv, this->className());
-}
-this->instance = curEnv->NewGlobalRef(localInstance) ;
-if(this->instance == NULL){
-throw GiwsException::JniObjectCreationException(curEnv, this->className());
+void ScilabVariables::endSynchronize()
+{
+    if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK)
+    {
+        throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabVariables");
+    }
 }
-/* localInstance not needed anymore */
-curEnv->DeleteLocalRef(localInstance);
-
-                /* Methods ID set to NULL */
-jobjectArray_getAllListenedVariablesID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejbooleanbooleanjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejobjectArray__doubledoublejbooleanbooleanjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID=NULL;
-voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID=NULL;
-voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID=NULL;
-voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__longlongjbooleanbooleanjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__booleanbooleanjbooleanbooleanjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__java_lang_Stringjava_lang_StringjbooleanbooleanjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjcharcharjintintID=NULL;
-voidcloseListjintArray_intintjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjintintID=NULL;
+// Method(s)
 
+char** ScilabVariables::getAllListenedVariables (JavaVM * jvm_)
+{
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    jmethodID jobjectArray_getAllListenedVariablesID = curEnv->GetStaticMethodID(cls, "getAllListenedVariables", "()[Ljava/lang/String;" ) ;
+    if (jobjectArray_getAllListenedVariablesID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "getAllListenedVariables");
+    }
+
+    jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getAllListenedVariablesID ));
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+    if (res != NULL)
+    {
+        int lenRow;
+        lenRow = curEnv->GetArrayLength(res);
+
+        char **arrayOfString;
+        arrayOfString = new char *[lenRow];
+        for (jsize i = 0; i < lenRow; i++)
+        {
+            jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
+            const char *tempString = curEnv->GetStringUTFChars(resString, 0);
+            arrayOfString[i] = new char[strlen(tempString) + 1];
+
+            strcpy(arrayOfString[i], tempString);
+            curEnv->ReleaseStringUTFChars(resString, tempString);
+            curEnv->DeleteLocalRef(resString);
+        }
+        curEnv->DeleteLocalRef(cls);
+        if (curEnv->ExceptionCheck())
+        {
+            delete[] arrayOfString;
+            throw GiwsException::JniCallMethodException(curEnv);
+        }
+        curEnv->DeleteLocalRef(res);
+        return arrayOfString;
+    }
+    else
+    {
+        curEnv->DeleteLocalRef(res);
+        return NULL;
+    }
 }
 
-ScilabVariables::ScilabVariables(JavaVM * jvm_, jobject JObj) {
-        jvm=jvm_;
+void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, double const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId)
+{
 
-        JNIEnv * curEnv = getCurrentEnv();
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jclass localClass = curEnv->GetObjectClass(JObj);
-        this->instanceClass = static_cast<jclass>(curEnv->NewGlobalRef(localClass));
-        curEnv->DeleteLocalRef(localClass);
+    jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[I[[DZI)V" ) ;
+    if (voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejbooleanbooleanjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
+    }
 
-        if (this->instanceClass == NULL) {
-throw GiwsException::JniObjectCreationException(curEnv, this->className());
-        }
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-        this->instance = curEnv->NewGlobalRef(JObj) ;
-        if(this->instance == NULL){
-throw GiwsException::JniObjectCreationException(curEnv, this->className());
-        }
-        /* Methods ID set to NULL */
-        jobjectArray_getAllListenedVariablesID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejbooleanbooleanjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejobjectArray__doubledoublejbooleanbooleanjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID=NULL;
-voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID=NULL;
-voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID=NULL;
-voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__longlongjbooleanbooleanjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__booleanbooleanjbooleanbooleanjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__java_lang_Stringjava_lang_StringjbooleanbooleanjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjcharcharjintintID=NULL;
-voidcloseListjintArray_intintjintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintID=NULL;
-voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjintintID=NULL;
 
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
 
-}
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-// Generic methods
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
-void ScilabVariables::synchronize() {
-if (getCurrentEnv()->MonitorEnter(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabVariables");
-}
-}
 
-void ScilabVariables::endSynchronize() {
-if ( getCurrentEnv()->MonitorExit(instance) != JNI_OK) {
-throw GiwsException::JniMonitorException(getCurrentEnv(), "ScilabVariables");
-}
-}
-// Method(s)
+    jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[D"), NULL);
 
-char** ScilabVariables::getAllListenedVariables (JavaVM * jvm_){
+    if (data_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    for (int i = 0; i < dataSize; i++)
+    {
 
-jmethodID jobjectArray_getAllListenedVariablesID = curEnv->GetStaticMethodID(cls, "getAllListenedVariables", "()[Ljava/lang/String;" ) ;
-if (jobjectArray_getAllListenedVariablesID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "getAllListenedVariables");
-}
+        jdoubleArray dataLocal = curEnv->NewDoubleArray( dataSizeCol ) ;
 
-                        jobjectArray res =  static_cast<jobjectArray>( curEnv->CallStaticObjectMethod(cls, jobjectArray_getAllListenedVariablesID ));
-                        if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}if (res != NULL) { int lenRow;
- lenRow = curEnv->GetArrayLength(res);
-
-char **arrayOfString;
-arrayOfString = new char *[lenRow];
-for (jsize i = 0; i < lenRow; i++){
-jstring resString = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
-const char *tempString = curEnv->GetStringUTFChars(resString, 0);
-arrayOfString[i] = new char[strlen(tempString) + 1];
-
-strcpy(arrayOfString[i], tempString);
-curEnv->ReleaseStringUTFChars(resString, tempString);
-curEnv->DeleteLocalRef(resString);
-}
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-delete[] arrayOfString;
-                                throw GiwsException::JniCallMethodException(curEnv);
-}
-curEnv->DeleteLocalRef(res);
-return arrayOfString;
- } else { 
-curEnv->DeleteLocalRef(res);
-return NULL;
-}
-}
+        if (dataLocal == NULL)
+        {
+            // check that allocation succeed
+            curEnv->DeleteLocalRef(data_);
+            throw GiwsException::JniBadAllocException(curEnv);
+        }
 
-void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, double const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId){
+        curEnv->SetDoubleArrayRegion( dataLocal, 0, dataSizeCol, (jdouble*)(data[i]) ) ;
+        curEnv->SetObjectArrayElement(data_, i, dataLocal);
+        curEnv->DeleteLocalRef(dataLocal);
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
 
-jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[I[[DZI)V" ) ;
-if (voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejbooleanbooleanjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
+    curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejbooleanbooleanjintintID , varName_, indexes_, data_, swaped_, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-jstring varName_ = curEnv->NewStringUTF( varName );
-if (varName != NULL && varName_ == NULL)
+void ScilabVariables::sendDataAsBuffer (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, double const* data, int dataSize, int rows, int cols, int handlerId)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+    jmethodID voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "sendDataAsBuffer", "(Ljava/lang/String;[ILjava/nio/DoubleBuffer;III)V" ) ;
+    if (voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjintintjintintjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendDataAsBuffer");
+    }
 
-if (indexes_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
 
- jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[D"),NULL);
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-if (data_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
- for (int i=0; i<dataSize; i++){
 
-jdoubleArray dataLocal = curEnv->NewDoubleArray( dataSizeCol ) ;
 
-if (dataLocal == NULL)
-{
-// check that allocation succeed
-curEnv->DeleteLocalRef(data_);
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jobject bufferdata = curEnv->NewDirectByteBuffer((void*)data, (jlong)dataSize * sizeof(double));
+    if (!bufferdata)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetDoubleArrayRegion( dataLocal, 0, dataSizeCol, (jdouble*)(data[i]) ) ;
-curEnv->SetObjectArrayElement(data_, i, dataLocal);
-curEnv->DeleteLocalRef(dataLocal);
-}
+    if (ByteOrderClass == NULL)
+    {
+        ByteOrderClass = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteOrder")));
+        if (ByteOrderClass == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (nativeOrderID == NULL)
+    {
+        // public static ByteOrder nativeOrder()
+        nativeOrderID = curEnv->GetStaticMethodID(ByteOrderClass, "nativeOrder", "()Ljava/nio/ByteOrder;");
+        if (nativeOrderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    nativeOrder = curEnv->CallStaticObjectMethod(ByteOrderClass, nativeOrderID, bufferdata);
+    //                        curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+
+    if (bbCls == NULL)
+    {
+        bbCls = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteBuffer")));
+        if (bbCls == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (orderID == NULL)
+    {
+        orderID = curEnv->GetMethodID(bbCls, "order", "(Ljava/nio/ByteOrder;)Ljava/nio/ByteBuffer;");
+        if (orderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+    bufferdata = curEnv->CallObjectMethod(bufferdata, orderID, nativeOrder);
 
-jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
 
-                         curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejbooleanbooleanjintintID ,varName_, indexes_, data_, swaped_, handlerId);
-                        curEnv->DeleteLocalRef(varName_);
-curEnv->DeleteLocalRef(indexes_);
-curEnv->DeleteLocalRef(data_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+    if (asdbIDDoubleBuffer == NULL)
+    {
+        asdbIDDoubleBuffer = curEnv->GetMethodID(bbCls, "asDoubleBuffer", "()Ljava/nio/DoubleBuffer;");
+        if (asdbIDDoubleBuffer == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
 
-void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, double const* const* real, int realSize, int realSizeCol, double const* const* img, int imgSize, int imgSizeCol, bool swaped, int handlerId){
+    jobject data_ = curEnv->CallObjectMethod(bufferdata, asdbIDDoubleBuffer);
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    if (data_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejobjectArray__doubledoublejbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[I[[D[[DZI)V" ) ;
-if (voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejobjectArray__doubledoublejbooleanbooleanjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
+    curEnv->CallStaticVoidMethod(cls, voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjintintjintintjintintID , varName_, indexes_, data_, rows, cols, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-jstring varName_ = curEnv->NewStringUTF( varName );
-if (varName != NULL && varName_ == NULL)
+void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, double const* const* real, int realSize, int realSizeCol, double const* const* img, int imgSize, int imgSizeCol, bool swaped, int handlerId)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+    jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejobjectArray__doubledoublejbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[I[[D[[DZI)V" ) ;
+    if (voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejobjectArray__doubledoublejbooleanbooleanjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
+    }
 
-if (indexes_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
 
- jobjectArray real_ = curEnv->NewObjectArray(realSize, curEnv->FindClass("[D"),NULL);
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-if (real_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
- for (int i=0; i<realSize; i++){
 
-jdoubleArray realLocal = curEnv->NewDoubleArray( realSizeCol ) ;
+    jobjectArray real_ = curEnv->NewObjectArray(realSize, curEnv->FindClass("[D"), NULL);
 
-if (realLocal == NULL)
-{
-// check that allocation succeed
-curEnv->DeleteLocalRef(real_);
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    if (real_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetDoubleArrayRegion( realLocal, 0, realSizeCol, (jdouble*)(real[i]) ) ;
-curEnv->SetObjectArrayElement(real_, i, realLocal);
-curEnv->DeleteLocalRef(realLocal);
-}
+    for (int i = 0; i < realSize; i++)
+    {
 
- jobjectArray img_ = curEnv->NewObjectArray(imgSize, curEnv->FindClass("[D"),NULL);
+        jdoubleArray realLocal = curEnv->NewDoubleArray( realSizeCol ) ;
 
-if (img_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+        if (realLocal == NULL)
+        {
+            // check that allocation succeed
+            curEnv->DeleteLocalRef(real_);
+            throw GiwsException::JniBadAllocException(curEnv);
+        }
 
- for (int i=0; i<imgSize; i++){
+        curEnv->SetDoubleArrayRegion( realLocal, 0, realSizeCol, (jdouble*)(real[i]) ) ;
+        curEnv->SetObjectArrayElement(real_, i, realLocal);
+        curEnv->DeleteLocalRef(realLocal);
+    }
 
-jdoubleArray imgLocal = curEnv->NewDoubleArray( imgSizeCol ) ;
+    jobjectArray img_ = curEnv->NewObjectArray(imgSize, curEnv->FindClass("[D"), NULL);
 
-if (imgLocal == NULL)
-{
-// check that allocation succeed
-curEnv->DeleteLocalRef(img_);
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    if (img_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetDoubleArrayRegion( imgLocal, 0, imgSizeCol, (jdouble*)(img[i]) ) ;
-curEnv->SetObjectArrayElement(img_, i, imgLocal);
-curEnv->DeleteLocalRef(imgLocal);
-}
+    for (int i = 0; i < imgSize; i++)
+    {
 
-jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
+        jdoubleArray imgLocal = curEnv->NewDoubleArray( imgSizeCol ) ;
 
-                         curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejobjectArray__doubledoublejbooleanbooleanjintintID ,varName_, indexes_, real_, img_, swaped_, handlerId);
-                        curEnv->DeleteLocalRef(varName_);
-curEnv->DeleteLocalRef(indexes_);
-curEnv->DeleteLocalRef(real_);
-curEnv->DeleteLocalRef(img_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+        if (imgLocal == NULL)
+        {
+            // check that allocation succeed
+            curEnv->DeleteLocalRef(img_);
+            throw GiwsException::JniBadAllocException(curEnv);
+        }
 
-void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, byte const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId){
+        curEnv->SetDoubleArrayRegion( imgLocal, 0, imgSizeCol, (jdouble*)(img[i]) ) ;
+        curEnv->SetObjectArrayElement(img_, i, imgLocal);
+        curEnv->DeleteLocalRef(imgLocal);
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
 
-jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[I[[BZI)V" ) ;
-if (voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
+    curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__doubledoublejobjectArray__doubledoublejbooleanbooleanjintintID , varName_, indexes_, real_, img_, swaped_, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(real_);
+    curEnv->DeleteLocalRef(img_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-jstring varName_ = curEnv->NewStringUTF( varName );
-if (varName != NULL && varName_ == NULL)
+void ScilabVariables::sendDataAsBuffer (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, double const* real, int realSize, double const* img, int imgSize, int rows, int cols, int handlerId)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+    jmethodID voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "sendDataAsBuffer", "(Ljava/lang/String;[ILjava/nio/DoubleBuffer;Ljava/nio/DoubleBuffer;III)V" ) ;
+    if (voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjintintjintintjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendDataAsBuffer");
+    }
 
-if (indexes_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
 
- jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[B"),NULL);
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-if (data_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
- for (int i=0; i<dataSize; i++){
 
-jbyteArray dataLocal = curEnv->NewByteArray( dataSizeCol ) ;
 
-if (dataLocal == NULL)
-{
-// check that allocation succeed
-curEnv->DeleteLocalRef(data_);
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jobject bufferreal = curEnv->NewDirectByteBuffer((void*)real, (jlong)realSize * sizeof(double));
+    if (!bufferreal)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetByteArrayRegion( dataLocal, 0, dataSizeCol, (jbyte*)(data[i]) ) ;
-curEnv->SetObjectArrayElement(data_, i, dataLocal);
-curEnv->DeleteLocalRef(dataLocal);
-}
+    if (ByteOrderClass == NULL)
+    {
+        ByteOrderClass = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteOrder")));
+        if (ByteOrderClass == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (nativeOrderID == NULL)
+    {
+        // public static ByteOrder nativeOrder()
+        nativeOrderID = curEnv->GetStaticMethodID(ByteOrderClass, "nativeOrder", "()Ljava/nio/ByteOrder;");
+        if (nativeOrderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    nativeOrder = curEnv->CallStaticObjectMethod(ByteOrderClass, nativeOrderID, bufferreal);
+    //                        curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+
+    if (bbCls == NULL)
+    {
+        bbCls = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteBuffer")));
+        if (bbCls == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (orderID == NULL)
+    {
+        orderID = curEnv->GetMethodID(bbCls, "order", "(Ljava/nio/ByteOrder;)Ljava/nio/ByteBuffer;");
+        if (orderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+    bufferreal = curEnv->CallObjectMethod(bufferreal, orderID, nativeOrder);
 
-jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
 
-                         curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID ,varName_, indexes_, data_, swaped_, handlerId);
-                        curEnv->DeleteLocalRef(varName_);
-curEnv->DeleteLocalRef(indexes_);
-curEnv->DeleteLocalRef(data_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+    if (asdbIDDoubleBuffer == NULL)
+    {
+        asdbIDDoubleBuffer = curEnv->GetMethodID(bbCls, "asDoubleBuffer", "()Ljava/nio/DoubleBuffer;");
+        if (asdbIDDoubleBuffer == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    jobject real_ = curEnv->CallObjectMethod(bufferreal, asdbIDDoubleBuffer);
+
+    if (real_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+
+    jobject bufferimg = curEnv->NewDirectByteBuffer((void*)img, (jlong)imgSize * sizeof(double));
+    if (!bufferimg)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    if (ByteOrderClass == NULL)
+    {
+        ByteOrderClass = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteOrder")));
+        if (ByteOrderClass == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (nativeOrderID == NULL)
+    {
+        // public static ByteOrder nativeOrder()
+        nativeOrderID = curEnv->GetStaticMethodID(ByteOrderClass, "nativeOrder", "()Ljava/nio/ByteOrder;");
+        if (nativeOrderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    nativeOrder = curEnv->CallStaticObjectMethod(ByteOrderClass, nativeOrderID, bufferimg);
+    //                        curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+
+    if (bbCls == NULL)
+    {
+        bbCls = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteBuffer")));
+        if (bbCls == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (orderID == NULL)
+    {
+        orderID = curEnv->GetMethodID(bbCls, "order", "(Ljava/nio/ByteOrder;)Ljava/nio/ByteBuffer;");
+        if (orderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+    bufferimg = curEnv->CallObjectMethod(bufferimg, orderID, nativeOrder);
+
+
+    if (asdbIDDoubleBuffer == NULL)
+    {
+        asdbIDDoubleBuffer = curEnv->GetMethodID(bbCls, "asDoubleBuffer", "()Ljava/nio/DoubleBuffer;");
+        if (asdbIDDoubleBuffer == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
 
-void ScilabVariables::sendUnsignedData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, byte const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId){
+    jobject img_ = curEnv->CallObjectMethod(bufferimg, asdbIDDoubleBuffer);
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    if (img_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-jmethodID voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendUnsignedData", "(Ljava/lang/String;[I[[BZI)V" ) ;
-if (voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "sendUnsignedData");
+    curEnv->CallStaticVoidMethod(cls, voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjobject_java_lang_DoubleBufferjava_lang_DoubleBufferjintintjintintjintintID , varName_, indexes_, real_, img_, rows, cols, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(real_);
+    curEnv->DeleteLocalRef(img_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-jstring varName_ = curEnv->NewStringUTF( varName );
-if (varName != NULL && varName_ == NULL)
+void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, byte const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+    jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[I[[BZI)V" ) ;
+    if (voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
+    }
 
-if (indexes_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
 
- jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[B"),NULL);
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-if (data_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
- for (int i=0; i<dataSize; i++){
 
-jbyteArray dataLocal = curEnv->NewByteArray( dataSizeCol ) ;
+    jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[B"), NULL);
 
-if (dataLocal == NULL)
-{
-// check that allocation succeed
-curEnv->DeleteLocalRef(data_);
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    if (data_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetByteArrayRegion( dataLocal, 0, dataSizeCol, (jbyte*)(data[i]) ) ;
-curEnv->SetObjectArrayElement(data_, i, dataLocal);
-curEnv->DeleteLocalRef(dataLocal);
-}
+    for (int i = 0; i < dataSize; i++)
+    {
 
-jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
+        jbyteArray dataLocal = curEnv->NewByteArray( dataSizeCol ) ;
 
-                         curEnv->CallStaticVoidMethod(cls, voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID ,varName_, indexes_, data_, swaped_, handlerId);
-                        curEnv->DeleteLocalRef(varName_);
-curEnv->DeleteLocalRef(indexes_);
-curEnv->DeleteLocalRef(data_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+        if (dataLocal == NULL)
+        {
+            // check that allocation succeed
+            curEnv->DeleteLocalRef(data_);
+            throw GiwsException::JniBadAllocException(curEnv);
+        }
 
-void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, short const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId){
+        curEnv->SetByteArrayRegion( dataLocal, 0, dataSizeCol, (jbyte*)(data[i]) ) ;
+        curEnv->SetObjectArrayElement(data_, i, dataLocal);
+        curEnv->DeleteLocalRef(dataLocal);
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
 
-jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[I[[SZI)V" ) ;
-if (voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
+    curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID , varName_, indexes_, data_, swaped_, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-jstring varName_ = curEnv->NewStringUTF( varName );
-if (varName != NULL && varName_ == NULL)
+void ScilabVariables::sendUnsignedData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, byte const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+    jmethodID voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendUnsignedData", "(Ljava/lang/String;[I[[BZI)V" ) ;
+    if (voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendUnsignedData");
+    }
 
-if (indexes_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
 
- jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[S"),NULL);
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-if (data_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
- for (int i=0; i<dataSize; i++){
 
-jshortArray dataLocal = curEnv->NewShortArray( dataSizeCol ) ;
+    jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[B"), NULL);
 
-if (dataLocal == NULL)
-{
-// check that allocation succeed
-curEnv->DeleteLocalRef(data_);
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    if (data_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetShortArrayRegion( dataLocal, 0, dataSizeCol, (jshort*)(data[i]) ) ;
-curEnv->SetObjectArrayElement(data_, i, dataLocal);
-curEnv->DeleteLocalRef(dataLocal);
-}
+    for (int i = 0; i < dataSize; i++)
+    {
 
-jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
+        jbyteArray dataLocal = curEnv->NewByteArray( dataSizeCol ) ;
 
-                         curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID ,varName_, indexes_, data_, swaped_, handlerId);
-                        curEnv->DeleteLocalRef(varName_);
-curEnv->DeleteLocalRef(indexes_);
-curEnv->DeleteLocalRef(data_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+        if (dataLocal == NULL)
+        {
+            // check that allocation succeed
+            curEnv->DeleteLocalRef(data_);
+            throw GiwsException::JniBadAllocException(curEnv);
+        }
 
-void ScilabVariables::sendUnsignedData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, short const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId){
+        curEnv->SetByteArrayRegion( dataLocal, 0, dataSizeCol, (jbyte*)(data[i]) ) ;
+        curEnv->SetObjectArrayElement(data_, i, dataLocal);
+        curEnv->DeleteLocalRef(dataLocal);
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
 
-jmethodID voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendUnsignedData", "(Ljava/lang/String;[I[[SZI)V" ) ;
-if (voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "sendUnsignedData");
+    curEnv->CallStaticVoidMethod(cls, voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__bytebytejbooleanbooleanjintintID , varName_, indexes_, data_, swaped_, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-jstring varName_ = curEnv->NewStringUTF( varName );
-if (varName != NULL && varName_ == NULL)
+void ScilabVariables::sendDataAsBuffer (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, byte const* data, int dataSize, int rows, int cols, int handlerId)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+    jmethodID voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ByteBufferjava_lang_ByteBufferjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "sendDataAsBuffer", "(Ljava/lang/String;[ILjava/nio/ByteBuffer;III)V" ) ;
+    if (voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ByteBufferjava_lang_ByteBufferjintintjintintjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendDataAsBuffer");
+    }
 
-if (indexes_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
 
- jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[S"),NULL);
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
-if (data_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
- for (int i=0; i<dataSize; i++){
 
-jshortArray dataLocal = curEnv->NewShortArray( dataSizeCol ) ;
+    jobject bufferdata = curEnv->NewDirectByteBuffer((void*)data, (jlong)dataSize * sizeof(byte));
+    if (!bufferdata)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-if (dataLocal == NULL)
+    if (ByteOrderClass == NULL)
+    {
+        ByteOrderClass = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteOrder")));
+        if (ByteOrderClass == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (nativeOrderID == NULL)
+    {
+        // public static ByteOrder nativeOrder()
+        nativeOrderID = curEnv->GetStaticMethodID(ByteOrderClass, "nativeOrder", "()Ljava/nio/ByteOrder;");
+        if (nativeOrderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    nativeOrder = curEnv->CallStaticObjectMethod(ByteOrderClass, nativeOrderID, bufferdata);
+    //                        curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+
+    if (bbCls == NULL)
+    {
+        bbCls = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteBuffer")));
+        if (bbCls == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (orderID == NULL)
+    {
+        orderID = curEnv->GetMethodID(bbCls, "order", "(Ljava/nio/ByteOrder;)Ljava/nio/ByteBuffer;");
+        if (orderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+    bufferdata = curEnv->CallObjectMethod(bufferdata, orderID, nativeOrder);
+
+    jobject data_ = bufferdata;
+    curEnv->CallStaticVoidMethod(cls, voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ByteBufferjava_lang_ByteBufferjintintjintintjintintID , varName_, indexes_, data_, rows, cols, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+}
+
+void ScilabVariables::sendUnsignedDataAsBuffer (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, byte const* data, int dataSize, int rows, int cols, int handlerId)
 {
-// check that allocation succeed
-curEnv->DeleteLocalRef(data_);
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-curEnv->SetShortArrayRegion( dataLocal, 0, dataSizeCol, (jshort*)(data[i]) ) ;
-curEnv->SetObjectArrayElement(data_, i, dataLocal);
-curEnv->DeleteLocalRef(dataLocal);
-}
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
+    jmethodID voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ByteBufferjava_lang_ByteBufferjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "sendUnsignedDataAsBuffer", "(Ljava/lang/String;[ILjava/nio/ByteBuffer;III)V" ) ;
+    if (voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ByteBufferjava_lang_ByteBufferjintintjintintjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendUnsignedDataAsBuffer");
+    }
 
-                         curEnv->CallStaticVoidMethod(cls, voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID ,varName_, indexes_, data_, swaped_, handlerId);
-                        curEnv->DeleteLocalRef(varName_);
-curEnv->DeleteLocalRef(indexes_);
-curEnv->DeleteLocalRef(data_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, int const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId){
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
 
-jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[I[[IZI)V" ) ;
-if (voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
-}
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
-jstring varName_ = curEnv->NewStringUTF( varName );
-if (varName != NULL && varName_ == NULL)
-{
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
 
-jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+    jobject bufferdata = curEnv->NewDirectByteBuffer((void*)data, (jlong)dataSize * sizeof(byte));
+    if (!bufferdata)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-if (indexes_ == NULL)
+    if (ByteOrderClass == NULL)
+    {
+        ByteOrderClass = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteOrder")));
+        if (ByteOrderClass == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (nativeOrderID == NULL)
+    {
+        // public static ByteOrder nativeOrder()
+        nativeOrderID = curEnv->GetStaticMethodID(ByteOrderClass, "nativeOrder", "()Ljava/nio/ByteOrder;");
+        if (nativeOrderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    nativeOrder = curEnv->CallStaticObjectMethod(ByteOrderClass, nativeOrderID, bufferdata);
+    //                        curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+
+    if (bbCls == NULL)
+    {
+        bbCls = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteBuffer")));
+        if (bbCls == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (orderID == NULL)
+    {
+        orderID = curEnv->GetMethodID(bbCls, "order", "(Ljava/nio/ByteOrder;)Ljava/nio/ByteBuffer;");
+        if (orderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+    bufferdata = curEnv->CallObjectMethod(bufferdata, orderID, nativeOrder);
+
+    jobject data_ = bufferdata;
+    curEnv->CallStaticVoidMethod(cls, voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ByteBufferjava_lang_ByteBufferjintintjintintjintintID , varName_, indexes_, data_, rows, cols, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+}
+
+void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, short const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
+    jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[I[[SZI)V" ) ;
+    if (voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
+    }
 
- jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[I"),NULL);
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-if (data_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
- for (int i=0; i<dataSize; i++){
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
 
-jintArray dataLocal = curEnv->NewIntArray( dataSizeCol ) ;
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-if (dataLocal == NULL)
-{
-// check that allocation succeed
-curEnv->DeleteLocalRef(data_);
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
-curEnv->SetIntArrayRegion( dataLocal, 0, dataSizeCol, (jint*)(data[i]) ) ;
-curEnv->SetObjectArrayElement(data_, i, dataLocal);
-curEnv->DeleteLocalRef(dataLocal);
-}
 
-jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
+    jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[S"), NULL);
 
-                         curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID ,varName_, indexes_, data_, swaped_, handlerId);
-                        curEnv->DeleteLocalRef(varName_);
-curEnv->DeleteLocalRef(indexes_);
-curEnv->DeleteLocalRef(data_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+    if (data_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    for (int i = 0; i < dataSize; i++)
+    {
+
+        jshortArray dataLocal = curEnv->NewShortArray( dataSizeCol ) ;
+
+        if (dataLocal == NULL)
+        {
+            // check that allocation succeed
+            curEnv->DeleteLocalRef(data_);
+            throw GiwsException::JniBadAllocException(curEnv);
+        }
 
-void ScilabVariables::sendUnsignedData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, int const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId){
+        curEnv->SetShortArrayRegion( dataLocal, 0, dataSizeCol, (jshort*)(data[i]) ) ;
+        curEnv->SetObjectArrayElement(data_, i, dataLocal);
+        curEnv->DeleteLocalRef(dataLocal);
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
 
-jmethodID voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendUnsignedData", "(Ljava/lang/String;[I[[IZI)V" ) ;
-if (voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "sendUnsignedData");
+    curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID , varName_, indexes_, data_, swaped_, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-jstring varName_ = curEnv->NewStringUTF( varName );
-if (varName != NULL && varName_ == NULL)
+void ScilabVariables::sendUnsignedData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, short const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+    jmethodID voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendUnsignedData", "(Ljava/lang/String;[I[[SZI)V" ) ;
+    if (voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendUnsignedData");
+    }
 
-if (indexes_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
 
- jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[I"),NULL);
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-if (data_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
- for (int i=0; i<dataSize; i++){
 
-jintArray dataLocal = curEnv->NewIntArray( dataSizeCol ) ;
+    jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[S"), NULL);
 
-if (dataLocal == NULL)
-{
-// check that allocation succeed
-curEnv->DeleteLocalRef(data_);
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    if (data_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetIntArrayRegion( dataLocal, 0, dataSizeCol, (jint*)(data[i]) ) ;
-curEnv->SetObjectArrayElement(data_, i, dataLocal);
-curEnv->DeleteLocalRef(dataLocal);
-}
+    for (int i = 0; i < dataSize; i++)
+    {
 
-jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
+        jshortArray dataLocal = curEnv->NewShortArray( dataSizeCol ) ;
 
-                         curEnv->CallStaticVoidMethod(cls, voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID ,varName_, indexes_, data_, swaped_, handlerId);
-                        curEnv->DeleteLocalRef(varName_);
-curEnv->DeleteLocalRef(indexes_);
-curEnv->DeleteLocalRef(data_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+        if (dataLocal == NULL)
+        {
+            // check that allocation succeed
+            curEnv->DeleteLocalRef(data_);
+            throw GiwsException::JniBadAllocException(curEnv);
+        }
 
-void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, long long const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId){
+        curEnv->SetShortArrayRegion( dataLocal, 0, dataSizeCol, (jshort*)(data[i]) ) ;
+        curEnv->SetObjectArrayElement(data_, i, dataLocal);
+        curEnv->DeleteLocalRef(dataLocal);
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
 
-jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__longlongjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[I[[JZI)V" ) ;
-if (voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__longlongjbooleanbooleanjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
+    curEnv->CallStaticVoidMethod(cls, voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__shortshortjbooleanbooleanjintintID , varName_, indexes_, data_, swaped_, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-jstring varName_ = curEnv->NewStringUTF( varName );
-if (varName != NULL && varName_ == NULL)
+void ScilabVariables::sendDataAsBuffer (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, short const* data, int dataSize, int rows, int cols, int handlerId)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+    jmethodID voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ShortBufferjava_lang_ShortBufferjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "sendDataAsBuffer", "(Ljava/lang/String;[ILjava/nio/ShortBuffer;III)V" ) ;
+    if (voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ShortBufferjava_lang_ShortBufferjintintjintintjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendDataAsBuffer");
+    }
 
-if (indexes_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
 
- jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[J"),NULL);
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-if (data_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
- for (int i=0; i<dataSize; i++){
 
-jlongArray dataLocal = curEnv->NewLongArray( dataSizeCol ) ;
 
-if (dataLocal == NULL)
-{
-// check that allocation succeed
-curEnv->DeleteLocalRef(data_);
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jobject bufferdata = curEnv->NewDirectByteBuffer((void*)data, (jlong)dataSize * sizeof(short));
+    if (!bufferdata)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetLongArrayRegion( dataLocal, 0, dataSizeCol, (jlong*)(data[i]) ) ;
-curEnv->SetObjectArrayElement(data_, i, dataLocal);
-curEnv->DeleteLocalRef(dataLocal);
-}
+    if (ByteOrderClass == NULL)
+    {
+        ByteOrderClass = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteOrder")));
+        if (ByteOrderClass == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (nativeOrderID == NULL)
+    {
+        // public static ByteOrder nativeOrder()
+        nativeOrderID = curEnv->GetStaticMethodID(ByteOrderClass, "nativeOrder", "()Ljava/nio/ByteOrder;");
+        if (nativeOrderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    nativeOrder = curEnv->CallStaticObjectMethod(ByteOrderClass, nativeOrderID, bufferdata);
+    //                        curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+
+    if (bbCls == NULL)
+    {
+        bbCls = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteBuffer")));
+        if (bbCls == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (orderID == NULL)
+    {
+        orderID = curEnv->GetMethodID(bbCls, "order", "(Ljava/nio/ByteOrder;)Ljava/nio/ByteBuffer;");
+        if (orderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+    bufferdata = curEnv->CallObjectMethod(bufferdata, orderID, nativeOrder);
 
-jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
 
-                         curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__longlongjbooleanbooleanjintintID ,varName_, indexes_, data_, swaped_, handlerId);
-                        curEnv->DeleteLocalRef(varName_);
-curEnv->DeleteLocalRef(indexes_);
-curEnv->DeleteLocalRef(data_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+    if (asdbIDShortBuffer == NULL)
+    {
+        asdbIDShortBuffer = curEnv->GetMethodID(bbCls, "asShortBuffer", "()Ljava/nio/ShortBuffer;");
+        if (asdbIDShortBuffer == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
 
-void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, bool const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId){
+    jobject data_ = curEnv->CallObjectMethod(bufferdata, asdbIDShortBuffer);
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    if (data_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__booleanbooleanjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[I[[ZZI)V" ) ;
-if (voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__booleanbooleanjbooleanbooleanjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
+    curEnv->CallStaticVoidMethod(cls, voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ShortBufferjava_lang_ShortBufferjintintjintintjintintID , varName_, indexes_, data_, rows, cols, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-jstring varName_ = curEnv->NewStringUTF( varName );
-if (varName != NULL && varName_ == NULL)
+void ScilabVariables::sendUnsignedDataAsBuffer (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, short const* data, int dataSize, int rows, int cols, int handlerId)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
-
 
-jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-if (indexes_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jmethodID voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ShortBufferjava_lang_ShortBufferjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "sendUnsignedDataAsBuffer", "(Ljava/lang/String;[ILjava/nio/ShortBuffer;III)V" ) ;
+    if (voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ShortBufferjava_lang_ShortBufferjintintjintintjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendUnsignedDataAsBuffer");
+    }
 
-curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
 
-jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[Z"),NULL);
-for (int i=0; i<dataSize; i++){
-                        jbooleanArray dataLocal = curEnv->NewBooleanArray( dataSizeCol ) ;
-                        curEnv->SetBooleanArrayRegion( dataLocal, 0, dataSizeCol, (jboolean*)(data[i]) ) ;
-                        curEnv->SetObjectArrayElement(data_, i, dataLocal);
-                        curEnv->DeleteLocalRef(dataLocal);
-                        }
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
 
-jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-                         curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__booleanbooleanjbooleanbooleanjintintID ,varName_, indexes_, data_, swaped_, handlerId);
-                        curEnv->DeleteLocalRef(varName_);
-curEnv->DeleteLocalRef(indexes_);
-curEnv->DeleteLocalRef(data_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
-void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, char const* const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId){
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
 
-jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__java_lang_Stringjava_lang_StringjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[I[[Ljava/lang/String;ZI)V" ) ;
-if (voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__java_lang_Stringjava_lang_StringjbooleanbooleanjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
-}
+    jobject bufferdata = curEnv->NewDirectByteBuffer((void*)data, (jlong)dataSize * sizeof(short));
+    if (!bufferdata)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-jstring varName_ = curEnv->NewStringUTF( varName );
-if (varName != NULL && varName_ == NULL)
-{
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    if (ByteOrderClass == NULL)
+    {
+        ByteOrderClass = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteOrder")));
+        if (ByteOrderClass == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (nativeOrderID == NULL)
+    {
+        // public static ByteOrder nativeOrder()
+        nativeOrderID = curEnv->GetStaticMethodID(ByteOrderClass, "nativeOrder", "()Ljava/nio/ByteOrder;");
+        if (nativeOrderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    nativeOrder = curEnv->CallStaticObjectMethod(ByteOrderClass, nativeOrderID, bufferdata);
+    //                        curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+
+    if (bbCls == NULL)
+    {
+        bbCls = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteBuffer")));
+        if (bbCls == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (orderID == NULL)
+    {
+        orderID = curEnv->GetMethodID(bbCls, "order", "(Ljava/nio/ByteOrder;)Ljava/nio/ByteBuffer;");
+        if (orderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+    bufferdata = curEnv->CallObjectMethod(bufferdata, orderID, nativeOrder);
 
 
-jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+    if (asdbIDShortBuffer == NULL)
+    {
+        asdbIDShortBuffer = curEnv->GetMethodID(bbCls, "asShortBuffer", "()Ljava/nio/ShortBuffer;");
+        if (asdbIDShortBuffer == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
 
-if (indexes_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jobject data_ = curEnv->CallObjectMethod(bufferdata, asdbIDShortBuffer);
 
-curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
+    if (data_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-jclass stringArrayClass = curEnv->FindClass("java/lang/String");
-// create java array of array of strings.
-jobjectArray data_ = curEnv->NewObjectArray( dataSize, curEnv->FindClass("[Ljava/lang/String;"), NULL);
-if (data_ == NULL)
-{
-throw GiwsException::JniBadAllocException(curEnv);
+    curEnv->CallStaticVoidMethod(cls, voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_ShortBufferjava_lang_ShortBufferjintintjintintjintintID , varName_, indexes_, data_, rows, cols, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-for ( int i = 0; i < dataSize; i++)
-{
-jobjectArray dataLocal = curEnv->NewObjectArray( dataSizeCol, stringArrayClass, NULL);
-// convert each char * to java strings and fill the java array.
-for ( int j = 0; j < dataSizeCol; j++) {
-jstring TempString = curEnv->NewStringUTF( data[i][j] );
-
-if (TempString == NULL)
+void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, int const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId)
 {
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-curEnv->SetObjectArrayElement( dataLocal, j, TempString);
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-// avoid keeping reference on to many strings
-curEnv->DeleteLocalRef(TempString);
-}
-curEnv->SetObjectArrayElement(data_, i, dataLocal);
-curEnv->DeleteLocalRef(dataLocal);
+    jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[I[[IZI)V" ) ;
+    if (voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
+    }
 
-}
-jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
-
-                         curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__java_lang_Stringjava_lang_StringjbooleanbooleanjintintID ,varName_, indexes_, data_, swaped_, handlerId);
-                        curEnv->DeleteLocalRef(stringArrayClass);
-curEnv->DeleteLocalRef(varName_);
-curEnv->DeleteLocalRef(indexes_);
-curEnv->DeleteLocalRef(data_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, unsigned short type, int handlerId){
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
 
-jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjcharcharjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[ICI)V" ) ;
-if (voidsendDatajstringjava_lang_StringjintArray_intintjcharcharjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
-}
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-jstring varName_ = curEnv->NewStringUTF( varName );
-if (varName != NULL && varName_ == NULL)
-{
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
 
-jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+    jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[I"), NULL);
 
-if (indexes_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    if (data_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
+    for (int i = 0; i < dataSize; i++)
+    {
 
+        jintArray dataLocal = curEnv->NewIntArray( dataSizeCol ) ;
 
-                         curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjcharcharjintintID ,varName_, indexes_, type, handlerId);
-                        curEnv->DeleteLocalRef(varName_);
-curEnv->DeleteLocalRef(indexes_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+        if (dataLocal == NULL)
+        {
+            // check that allocation succeed
+            curEnv->DeleteLocalRef(data_);
+            throw GiwsException::JniBadAllocException(curEnv);
+        }
 
-void ScilabVariables::closeList (JavaVM * jvm_, int const* indexes, int indexesSize, int handlerId){
+        curEnv->SetIntArrayRegion( dataLocal, 0, dataSizeCol, (jint*)(data[i]) ) ;
+        curEnv->SetObjectArrayElement(data_, i, dataLocal);
+        curEnv->DeleteLocalRef(dataLocal);
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
 
-jmethodID voidcloseListjintArray_intintjintintID = curEnv->GetStaticMethodID(cls, "closeList", "([II)V" ) ;
-if (voidcloseListjintArray_intintjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "closeList");
+    curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID , varName_, indexes_, data_, swaped_, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
-
-if (indexes_ == NULL)
+void ScilabVariables::sendUnsignedData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, int const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
+    jmethodID voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendUnsignedData", "(Ljava/lang/String;[I[[IZI)V" ) ;
+    if (voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendUnsignedData");
+    }
 
-                         curEnv->CallStaticVoidMethod(cls, voidcloseListjintArray_intintjintintID ,indexes_, handlerId);
-                        curEnv->DeleteLocalRef(indexes_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, int row, int col, int nbItem, int const* nbItemRow, int nbItemRowSize, int const* colPos, int colPosSize, double const* data, int dataSize, int handlerId){
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
 
-jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[IIII[I[I[DI)V" ) ;
-if (voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
-}
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-jstring varName_ = curEnv->NewStringUTF( varName );
-if (varName != NULL && varName_ == NULL)
-{
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
 
-jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+    jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[I"), NULL);
 
-if (indexes_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    if (data_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    for (int i = 0; i < dataSize; i++)
+    {
 
-curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
+        jintArray dataLocal = curEnv->NewIntArray( dataSizeCol ) ;
 
+        if (dataLocal == NULL)
+        {
+            // check that allocation succeed
+            curEnv->DeleteLocalRef(data_);
+            throw GiwsException::JniBadAllocException(curEnv);
+        }
 
-jintArray nbItemRow_ = curEnv->NewIntArray( nbItemRowSize ) ;
+        curEnv->SetIntArrayRegion( dataLocal, 0, dataSizeCol, (jint*)(data[i]) ) ;
+        curEnv->SetObjectArrayElement(data_, i, dataLocal);
+        curEnv->DeleteLocalRef(dataLocal);
+    }
 
-if (nbItemRow_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
+    jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
+
+    curEnv->CallStaticVoidMethod(cls, voidsendUnsignedDatajstringjava_lang_StringjintArray_intintjobjectArray__intintjbooleanbooleanjintintID , varName_, indexes_, data_, swaped_, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-curEnv->SetIntArrayRegion( nbItemRow_, 0, nbItemRowSize, (jint*)(nbItemRow) ) ;
+void ScilabVariables::sendDataAsBuffer (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, int const* data, int dataSize, int rows, int cols, int handlerId)
+{
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-jintArray colPos_ = curEnv->NewIntArray( colPosSize ) ;
+    jmethodID voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_IntBufferjava_lang_IntBufferjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "sendDataAsBuffer", "(Ljava/lang/String;[ILjava/nio/IntBuffer;III)V" ) ;
+    if (voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_IntBufferjava_lang_IntBufferjintintjintintjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendDataAsBuffer");
+    }
 
-if (colPos_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-curEnv->SetIntArrayRegion( colPos_, 0, colPosSize, (jint*)(colPos) ) ;
 
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
 
-jdoubleArray data_ = curEnv->NewDoubleArray( dataSize ) ;
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-if (data_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
-curEnv->SetDoubleArrayRegion( data_, 0, dataSize, (jdouble*)(data) ) ;
 
 
-                         curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejintintID ,varName_, indexes_, row, col, nbItem, nbItemRow_, colPos_, data_, handlerId);
-                        curEnv->DeleteLocalRef(varName_);
-curEnv->DeleteLocalRef(indexes_);
-curEnv->DeleteLocalRef(nbItemRow_);
-curEnv->DeleteLocalRef(colPos_);
-curEnv->DeleteLocalRef(data_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+    jobject bufferdata = curEnv->NewDirectByteBuffer((void*)data, (jlong)dataSize * sizeof(int));
+    if (!bufferdata)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, int row, int col, int nbItem, int const* nbItemRow, int nbItemRowSize, int const* colPos, int colPosSize, double const* real, int realSize, double const* imag, int imagSize, int handlerId){
+    if (ByteOrderClass == NULL)
+    {
+        ByteOrderClass = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteOrder")));
+        if (ByteOrderClass == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (nativeOrderID == NULL)
+    {
+        // public static ByteOrder nativeOrder()
+        nativeOrderID = curEnv->GetStaticMethodID(ByteOrderClass, "nativeOrder", "()Ljava/nio/ByteOrder;");
+        if (nativeOrderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    nativeOrder = curEnv->CallStaticObjectMethod(ByteOrderClass, nativeOrderID, bufferdata);
+    //                        curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+
+    if (bbCls == NULL)
+    {
+        bbCls = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteBuffer")));
+        if (bbCls == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (orderID == NULL)
+    {
+        orderID = curEnv->GetMethodID(bbCls, "order", "(Ljava/nio/ByteOrder;)Ljava/nio/ByteBuffer;");
+        if (orderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+    bufferdata = curEnv->CallObjectMethod(bufferdata, orderID, nativeOrder);
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
 
-jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[IIII[I[I[D[DI)V" ) ;
-if (voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
-}
+    if (asdbIDIntBuffer == NULL)
+    {
+        asdbIDIntBuffer = curEnv->GetMethodID(bbCls, "asIntBuffer", "()Ljava/nio/IntBuffer;");
+        if (asdbIDIntBuffer == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
 
-jstring varName_ = curEnv->NewStringUTF( varName );
-if (varName != NULL && varName_ == NULL)
-{
-throw GiwsException::JniBadAllocException(curEnv);
-}
+    jobject data_ = curEnv->CallObjectMethod(bufferdata, asdbIDIntBuffer);
 
+    if (data_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+    curEnv->CallStaticVoidMethod(cls, voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_IntBufferjava_lang_IntBufferjintintjintintjintintID , varName_, indexes_, data_, rows, cols, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+}
 
-if (indexes_ == NULL)
+void ScilabVariables::sendUnsignedDataAsBuffer (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, int const* data, int dataSize, int rows, int cols, int handlerId)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
+    jmethodID voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_IntBufferjava_lang_IntBufferjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "sendUnsignedDataAsBuffer", "(Ljava/lang/String;[ILjava/nio/IntBuffer;III)V" ) ;
+    if (voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_IntBufferjava_lang_IntBufferjintintjintintjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendUnsignedDataAsBuffer");
+    }
 
-jintArray nbItemRow_ = curEnv->NewIntArray( nbItemRowSize ) ;
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-if (nbItemRow_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-curEnv->SetIntArrayRegion( nbItemRow_, 0, nbItemRowSize, (jint*)(nbItemRow) ) ;
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
 
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-jintArray colPos_ = curEnv->NewIntArray( colPosSize ) ;
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
 
-if (colPos_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-curEnv->SetIntArrayRegion( colPos_, 0, colPosSize, (jint*)(colPos) ) ;
 
+    jobject bufferdata = curEnv->NewDirectByteBuffer((void*)data, (jlong)dataSize * sizeof(int));
+    if (!bufferdata)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-jdoubleArray real_ = curEnv->NewDoubleArray( realSize ) ;
+    if (ByteOrderClass == NULL)
+    {
+        ByteOrderClass = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteOrder")));
+        if (ByteOrderClass == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (nativeOrderID == NULL)
+    {
+        // public static ByteOrder nativeOrder()
+        nativeOrderID = curEnv->GetStaticMethodID(ByteOrderClass, "nativeOrder", "()Ljava/nio/ByteOrder;");
+        if (nativeOrderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    nativeOrder = curEnv->CallStaticObjectMethod(ByteOrderClass, nativeOrderID, bufferdata);
+    //                        curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+
+    if (bbCls == NULL)
+    {
+        bbCls = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteBuffer")));
+        if (bbCls == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (orderID == NULL)
+    {
+        orderID = curEnv->GetMethodID(bbCls, "order", "(Ljava/nio/ByteOrder;)Ljava/nio/ByteBuffer;");
+        if (orderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+    bufferdata = curEnv->CallObjectMethod(bufferdata, orderID, nativeOrder);
 
-if (real_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
-}
 
-curEnv->SetDoubleArrayRegion( real_, 0, realSize, (jdouble*)(real) ) ;
+    if (asdbIDIntBuffer == NULL)
+    {
+        asdbIDIntBuffer = curEnv->GetMethodID(bbCls, "asIntBuffer", "()Ljava/nio/IntBuffer;");
+        if (asdbIDIntBuffer == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
 
+    jobject data_ = curEnv->CallObjectMethod(bufferdata, asdbIDIntBuffer);
 
-jdoubleArray imag_ = curEnv->NewDoubleArray( imagSize ) ;
+    if (data_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-if (imag_ == NULL)
-{
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
+    curEnv->CallStaticVoidMethod(cls, voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_IntBufferjava_lang_IntBufferjintintjintintjintintID , varName_, indexes_, data_, rows, cols, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-curEnv->SetDoubleArrayRegion( imag_, 0, imagSize, (jdouble*)(imag) ) ;
+void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, long long const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId)
+{
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 
-                         curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjdoubleArray_doubledoublejdoubleArray_doubledoublejintintID ,varName_, indexes_, row, col, nbItem, nbItemRow_, colPos_, real_, imag_, handlerId);
-                        curEnv->DeleteLocalRef(varName_);
-curEnv->DeleteLocalRef(indexes_);
-curEnv->DeleteLocalRef(nbItemRow_);
-curEnv->DeleteLocalRef(colPos_);
-curEnv->DeleteLocalRef(real_);
-curEnv->DeleteLocalRef(imag_);
-curEnv->DeleteLocalRef(cls);
-if (curEnv->ExceptionCheck()) {
-throw GiwsException::JniCallMethodException(curEnv);
-}
-}
+    jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__longlongjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[I[[JZI)V" ) ;
+    if (voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__longlongjbooleanbooleanjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
+    }
 
-void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, int row, int col, int nbItem, int const* nbItemRow, int nbItemRowSize, int const* colPos, int colPosSize, int handlerId){
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-JNIEnv * curEnv = NULL;
-jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
-jclass cls = curEnv->FindClass( className().c_str() );
 
-jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[IIII[I[II)V" ) ;
-if (voidsendDatajstringjava_lang_StringjintArray_intintjintintjintintjintintjintArray_intintjintArray_intintjintintID == NULL) {
-throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
-}
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
 
-jstring varName_ = curEnv->NewStringUTF( varName );
-if (varName != NULL && varName_ == NULL)
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
+
+
+    jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[J"), NULL);
+
+    if (data_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    for (int i = 0; i < dataSize; i++)
+    {
+
+        jlongArray dataLocal = curEnv->NewLongArray( dataSizeCol ) ;
+
+        if (dataLocal == NULL)
+        {
+            // check that allocation succeed
+            curEnv->DeleteLocalRef(data_);
+            throw GiwsException::JniBadAllocException(curEnv);
+        }
+
+        curEnv->SetLongArrayRegion( dataLocal, 0, dataSizeCol, (jlong*)(data[i]) ) ;
+        curEnv->SetObjectArrayElement(data_, i, dataLocal);
+        curEnv->DeleteLocalRef(dataLocal);
+    }
+
+    jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
+
+    curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__longlongjbooleanbooleanjintintID , varName_, indexes_, data_, swaped_, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+}
+
+void ScilabVariables::sendDataAsBuffer (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, long long const* data, int dataSize, int rows, int cols, int handlerId)
 {
-throw GiwsException::JniBadAllocException(curEnv);
+
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    jmethodID voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_LongBufferjava_lang_LongBufferjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "sendDataAsBuffer", "(Ljava/lang/String;[ILjava/nio/LongBuffer;III)V" ) ;
+    if (voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_LongBufferjava_lang_LongBufferjintintjintintjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendDataAsBuffer");
+    }
+
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
+
+
+
+    jobject bufferdata = curEnv->NewDirectByteBuffer((void*)data, (jlong)dataSize * sizeof(long long));
+    if (!bufferdata)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    if (ByteOrderClass == NULL)
+    {
+        ByteOrderClass = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteOrder")));
+        if (ByteOrderClass == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (nativeOrderID == NULL)
+    {
+        // public static ByteOrder nativeOrder()
+        nativeOrderID = curEnv->GetStaticMethodID(ByteOrderClass, "nativeOrder", "()Ljava/nio/ByteOrder;");
+        if (nativeOrderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    nativeOrder = curEnv->CallStaticObjectMethod(ByteOrderClass, nativeOrderID, bufferdata);
+    //                        curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+
+    if (bbCls == NULL)
+    {
+        bbCls = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteBuffer")));
+        if (bbCls == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (orderID == NULL)
+    {
+        orderID = curEnv->GetMethodID(bbCls, "order", "(Ljava/nio/ByteOrder;)Ljava/nio/ByteBuffer;");
+        if (orderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+    bufferdata = curEnv->CallObjectMethod(bufferdata, orderID, nativeOrder);
+
+
+    if (asdbIDLongBuffer == NULL)
+    {
+        asdbIDLongBuffer = curEnv->GetMethodID(bbCls, "asLongBuffer", "()Ljava/nio/LongBuffer;");
+        if (asdbIDLongBuffer == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    jobject data_ = curEnv->CallObjectMethod(bufferdata, asdbIDLongBuffer);
+
+    if (data_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    curEnv->CallStaticVoidMethod(cls, voidsendDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_LongBufferjava_lang_LongBufferjintintjintintjintintID , varName_, indexes_, data_, rows, cols, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
+void ScilabVariables::sendUnsignedDataAsBuffer (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, long long const* data, int dataSize, int rows, int cols, int handlerId)
+{
+
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    jmethodID voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_LongBufferjava_lang_LongBufferjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "sendUnsignedDataAsBuffer", "(Ljava/lang/String;[ILjava/nio/LongBuffer;III)V" ) ;
+    if (voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_LongBufferjava_lang_LongBufferjintintjintintjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendUnsignedDataAsBuffer");
+    }
 
-jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
 
-if (indexes_ == NULL)
+
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
+
+
+
+    jobject bufferdata = curEnv->NewDirectByteBuffer((void*)data, (jlong)dataSize * sizeof(long long));
+    if (!bufferdata)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    if (ByteOrderClass == NULL)
+    {
+        ByteOrderClass = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteOrder")));
+        if (ByteOrderClass == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (nativeOrderID == NULL)
+    {
+        // public static ByteOrder nativeOrder()
+        nativeOrderID = curEnv->GetStaticMethodID(ByteOrderClass, "nativeOrder", "()Ljava/nio/ByteOrder;");
+        if (nativeOrderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    nativeOrder = curEnv->CallStaticObjectMethod(ByteOrderClass, nativeOrderID, bufferdata);
+    //                        curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+
+    if (bbCls == NULL)
+    {
+        bbCls = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteBuffer")));
+        if (bbCls == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (orderID == NULL)
+    {
+        orderID = curEnv->GetMethodID(bbCls, "order", "(Ljava/nio/ByteOrder;)Ljava/nio/ByteBuffer;");
+        if (orderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+    bufferdata = curEnv->CallObjectMethod(bufferdata, orderID, nativeOrder);
+
+
+    if (asdbIDLongBuffer == NULL)
+    {
+        asdbIDLongBuffer = curEnv->GetMethodID(bbCls, "asLongBuffer", "()Ljava/nio/LongBuffer;");
+        if (asdbIDLongBuffer == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    jobject data_ = curEnv->CallObjectMethod(bufferdata, asdbIDLongBuffer);
+
+    if (data_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    curEnv->CallStaticVoidMethod(cls, voidsendUnsignedDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_LongBufferjava_lang_LongBufferjintintjintintjintintID , varName_, indexes_, data_, rows, cols, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+}
+
+void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, bool const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId)
 {
-// check that allocation succeed
-throw GiwsException::JniBadAllocException(curEnv);
+
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    jmethodID voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__booleanbooleanjbooleanbooleanjintintID = curEnv->GetStaticMethodID(cls, "sendData", "(Ljava/lang/String;[I[[ZZI)V" ) ;
+    if (voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__booleanbooleanjbooleanbooleanjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendData");
+    }
+
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
+
+
+    jobjectArray data_ = curEnv->NewObjectArray(dataSize, curEnv->FindClass("[Z"), NULL);
+    for (int i = 0; i < dataSize; i++)
+    {
+        jbooleanArray dataLocal = curEnv->NewBooleanArray( dataSizeCol ) ;
+        curEnv->SetBooleanArrayRegion( dataLocal, 0, dataSizeCol, (jboolean*)(data[i]) ) ;
+        curEnv->SetObjectArrayElement(data_, i, dataLocal);
+        curEnv->DeleteLocalRef(dataLocal);
+    }
+
+    jboolean swaped_ = (static_cast<bool>(swaped) ? JNI_TRUE : JNI_FALSE);
+
+    curEnv->CallStaticVoidMethod(cls, voidsendDatajstringjava_lang_StringjintArray_intintjobjectArray__booleanbooleanjbooleanbooleanjintintID , varName_, indexes_, data_, swaped_, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+}
+
+void ScilabVariables::sendBooleanDataAsBuffer (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, int const* data, int dataSize, int rows, int cols, int handlerId)
+{
+
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+    jmethodID voidsendBooleanDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_IntBufferjava_lang_IntBufferjintintjintintjintintID = curEnv->GetStaticMethodID(cls, "sendBooleanDataAsBuffer", "(Ljava/lang/String;[ILjava/nio/IntBuffer;III)V" ) ;
+    if (voidsendBooleanDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_IntBufferjava_lang_IntBufferjintintjintintjintintID == NULL)
+    {
+        throw GiwsException::JniMethodNotFoundException(curEnv, "sendBooleanDataAsBuffer");
+    }
+
+    jstring varName_ = curEnv->NewStringUTF( varName );
+    if (varName != NULL && varName_ == NULL)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+
+    jintArray indexes_ = curEnv->NewIntArray( indexesSize ) ;
+
+    if (indexes_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
+
+
+
+    jobject bufferdata = curEnv->NewDirectByteBuffer((void*)data, (jlong)dataSize * sizeof(int));
+    if (!bufferdata)
+    {
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    if (ByteOrderClass == NULL)
+    {
+        ByteOrderClass = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteOrder")));
+        if (ByteOrderClass == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (nativeOrderID == NULL)
+    {
+        // public static ByteOrder nativeOrder()
+        nativeOrderID = curEnv->GetStaticMethodID(ByteOrderClass, "nativeOrder", "()Ljava/nio/ByteOrder;");
+        if (nativeOrderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    nativeOrder = curEnv->CallStaticObjectMethod(ByteOrderClass, nativeOrderID, bufferdata);
+    //                        curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
+
+
+    if (bbCls == NULL)
+    {
+        bbCls = static_cast<jclass>(curEnv->NewGlobalRef(curEnv->FindClass("java/nio/ByteBuffer")));
+        if (bbCls == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    if (orderID == NULL)
+    {
+        orderID = curEnv->GetMethodID(bbCls, "order", "(Ljava/nio/ByteOrder;)Ljava/nio/ByteBuffer;");
+        if (orderID == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+    bufferdata = curEnv->CallObjectMethod(bufferdata, orderID, nativeOrder);
+
+
+    if (asdbIDIntBuffer == NULL)
+    {
+        asdbIDIntBuffer = curEnv->GetMethodID(bbCls, "asIntBuffer", "()Ljava/nio/IntBuffer;");
+        if (asdbIDIntBuffer == NULL)
+        {
+            curEnv->ExceptionDescribe();
+        }
+    }
+
+    jobject data_ = curEnv->CallObjectMethod(bufferdata, asdbIDIntBuffer);
+
+    if (data_ == NULL)
+    {
+        // check that allocation succeed
+        throw GiwsException::JniBadAllocException(curEnv);
+    }
+
+    curEnv->CallStaticVoidMethod(cls, voidsendBooleanDataAsBufferjstringjava_lang_StringjintArray_intintjobject_java_lang_IntBufferjava_lang_IntBufferjintintjintintjintintID , varName_, indexes_, data_, rows, cols, handlerId);
+    curEnv->DeleteLocalRef(varName_);
+    curEnv->DeleteLocalRef(indexes_);
+    curEnv->DeleteLocalRef(data_);
+    curEnv->DeleteLocalRef(cls);
+    if (curEnv->ExceptionCheck())
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }
 }
 
-curEnv->SetIntArrayRegion( indexes_, 0, indexesSize, (jint*)(indexes) ) ;
+void ScilabVariables::sendData (JavaVM * jvm_, char const* varName, int const* indexes, int indexesSize, char const* const* const* data, int dataSize, int dataSizeCol, bool swaped, int handlerId)
+{
 
+    JNIEnv * curEnv = NULL;
+    jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
+    jclass cls = curEnv->FindClass( className().c_str() );
+    if ( cls == NULL)
+    {
+        throw GiwsException::JniCallMethodException(curEnv);
+    }