JIMS: plug extraction
[scilab.git] / scilab / modules / external_objects_java / src / cpp / ScilabJavaObjectHelper.hxx
1 /*
2  * JIMS ( http://forge.scilab.org/index.php/p/JIMS/ ) - This file is a part of JIMS
3  * Copyright (C) 2010 - 2011 - Calixte DENIZET <calixte@contrib.scilab.org>
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12
13 #include <jni.h>
14 #include "GiwsException.hxx"
15 #include "NoMoreScilabMemoryException.hxx"
16 #include "ScilabObjects.hxx"
17 #include "OptionsHelper.hxx"
18
19 #define SCILABJAVAOBJECT "org/scilab/forge/jims/ScilabJavaObject"
20
21 #define __getFunctionNameForDB__(Type,type) static const char* getFunctionNameForDB(type *addr) \
22     {                                                                   \
23         return "wrapAsDirect" #Type "Buffer";                           \
24     }
25
26 struct ScilabJavaObjectHelper
27 {
28
29     __getFunctionNameForDB__(Double, double);
30     __getFunctionNameForDB__(Int, int);
31     __getFunctionNameForDB__(Char, char);
32     __getFunctionNameForDB__(Short, short);
33     __getFunctionNameForDB__(Long, long);
34     __getFunctionNameForDB__(Byte, byte);
35     __getFunctionNameForDB__(Float, float);
36
37     template <typename U> static void* wrapAsDirectBuffer(JavaVM * jvm_, U* address, long size, int *javaID);
38     static void releaseDirectBuffer(JavaVM * jvm_, void** ref, int* javaID, int len);
39
40     static void getMethodResult(JavaVM * jvm_, const char * const methodName, int id, int pos)
41     {
42         JNIEnv * curEnv = NULL;
43         jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
44         jclass cls = curEnv->FindClass(SCILABJAVAOBJECT);
45
46         jmethodID jobjectArray_getAccessibleMethodsjintID = curEnv->GetStaticMethodID(cls, methodName, "(I)[Ljava/lang/String;");
47         if (jobjectArray_getAccessibleMethodsjintID == NULL)
48         {
49             throw GiwsException::JniMethodNotFoundException(curEnv, methodName);
50         }
51
52         jobjectArray res = static_cast<jobjectArray>(curEnv->CallStaticObjectMethod(cls, jobjectArray_getAccessibleMethodsjintID, id));
53         if (curEnv->ExceptionCheck())
54         {
55             throw GiwsException::JniCallMethodException(curEnv);
56         }
57         jint lenRow = curEnv->GetArrayLength(res);
58         jboolean isCopy = JNI_FALSE;
59
60         char **addr = new char*[lenRow];
61         jstring *resString = new jstring[lenRow];
62
63         for (jsize i = 0; i < lenRow; i++)
64         {
65             resString[i] = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
66             addr[i] = const_cast<char *>(curEnv->GetStringUTFChars(resString[i], &isCopy));
67         }
68
69         int lenCol = lenRow == 0 ? 0 : 1;
70         SciErr err = createMatrixOfString(pvApiCtx, pos, lenCol, lenRow, addr);
71
72         for (jsize i = 0; i < lenRow; i++)
73         {
74             curEnv->ReleaseStringUTFChars(resString[i], addr[i]);
75             curEnv->DeleteLocalRef(resString[i]);
76         }
77         delete[] addr;
78         delete[] resString;
79
80         if (err.iErr)
81         {
82             throw org_scilab_modules_external_objects_java::NoMoreScilabMemoryException();
83         }
84
85         curEnv->DeleteLocalRef(res);
86         curEnv->DeleteLocalRef(cls);
87         if (curEnv->ExceptionCheck())
88         {
89             throw GiwsException::JniCallMethodException(curEnv);
90         }
91     };
92
93     static void unwrapString(JavaVM * jvm_, int id, int pos)
94     {
95         JNIEnv * curEnv = NULL;
96         jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
97         jclass cls = curEnv->FindClass(SCILABJAVAOBJECT);
98
99         jmethodID jstringunwrapStringjintID = curEnv->GetStaticMethodID(cls, "unwrapString", "(I)Ljava/lang/String;" ) ;
100         if (jstringunwrapStringjintID == NULL)
101         {
102             throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapString");
103         }
104
105         jstring res = static_cast<jstring>(curEnv->CallStaticObjectMethod(cls, jstringunwrapStringjintID , id));
106         char *addr = const_cast<char *>(curEnv->GetStringUTFChars(res, 0));
107         SciErr err = createMatrixOfString(pvApiCtx, pos, 1, 1, &addr);
108         if (err.iErr)
109         {
110             throw org_scilab_modules_external_objects_java::NoMoreScilabMemoryException();
111         }
112
113         curEnv->ReleaseStringUTFChars(res, addr);
114         curEnv->DeleteLocalRef(res);
115         if (curEnv->ExceptionCheck())
116         {
117             throw GiwsException::JniCallMethodException(curEnv);
118         }
119     }
120
121     static void unwrapRowString(JavaVM * jvm_, int id, int pos)
122     {
123         JNIEnv * curEnv = NULL;
124         jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
125         jclass cls = curEnv->FindClass(SCILABJAVAOBJECT);
126
127         jmethodID jobjectArray_unwrapRowStringjintID = curEnv->GetStaticMethodID(cls, "unwrapRowString", "(I)[Ljava/lang/String;" );
128         if (jobjectArray_unwrapRowStringjintID == NULL)
129         {
130             throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapRowString");
131         }
132
133         jobjectArray res = static_cast<jobjectArray>(curEnv->CallStaticObjectMethod(cls, jobjectArray_unwrapRowStringjintID , id));
134         if (curEnv->ExceptionCheck())
135         {
136             throw GiwsException::JniCallMethodException(curEnv);
137         }
138
139         jint lenRow = curEnv->GetArrayLength(res);
140         jboolean isCopy = JNI_FALSE;
141         char **addr = new char*[lenRow];
142         jstring *resString = new jstring[lenRow];
143
144         for (jsize i = 0; i < lenRow; i++)
145         {
146             resString[i] = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(res, i));
147             addr[i] = const_cast<char *>(curEnv->GetStringUTFChars(resString[i], &isCopy));
148         }
149
150         SciErr err = createMatrixOfString(pvApiCtx, pos, 1, lenRow, addr);
151
152         for (jsize i = 0; i < lenRow; i++)
153         {
154             curEnv->ReleaseStringUTFChars(resString[i], addr[i]);
155             curEnv->DeleteLocalRef(resString[i]);
156         }
157         delete[] addr;
158         delete[] resString;
159
160         if (err.iErr)
161         {
162             throw org_scilab_modules_external_objects_java::NoMoreScilabMemoryException();
163         }
164
165         curEnv->DeleteLocalRef(res);
166         if (curEnv->ExceptionCheck())
167         {
168             throw GiwsException::JniCallMethodException(curEnv);
169         }
170     }
171
172     static void unwrapMatString(JavaVM * jvm_, int id, int pos)
173     {
174         JNIEnv * curEnv = NULL;
175         jvm_->AttachCurrentThread(reinterpret_cast<void **>(&curEnv), NULL);
176         jclass cls = curEnv->FindClass(SCILABJAVAOBJECT);
177
178         jmethodID jobjectArray__unwrapMatStringjintID = curEnv->GetStaticMethodID(cls, "unwrapMatString", "(I)[[Ljava/lang/String;" ) ;
179         if (jobjectArray__unwrapMatStringjintID == NULL)
180         {
181             throw GiwsException::JniMethodNotFoundException(curEnv, "unwrapMatString");
182         }
183
184         jobjectArray res = static_cast<jobjectArray>(curEnv->CallStaticObjectMethod(cls, jobjectArray__unwrapMatStringjintID , id));
185         if (curEnv->ExceptionCheck())
186         {
187             throw GiwsException::JniCallMethodException(curEnv);
188         }
189         jint lenRow = curEnv->GetArrayLength(res);
190         jboolean isCopy = JNI_FALSE;
191
192         jobjectArray oneDim = reinterpret_cast<jobjectArray>(curEnv->GetObjectArrayElement(res, 0));
193         jint lenCol = curEnv->GetArrayLength(oneDim);
194         char **addr = new char*[lenRow * lenCol];
195         jstring *resString = new jstring[lenRow * lenCol];
196
197         for (int i = 0; i < lenRow; i++)
198         {
199             oneDim = reinterpret_cast<jobjectArray>(curEnv->GetObjectArrayElement(res, i));
200             if (getMethodOfConv())
201             {
202                 for (int j = 0; j < lenCol; j++)
203                 {
204                     resString[j * lenRow + i] = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(oneDim, j));
205                     addr[j * lenRow + i] = const_cast<char *>(curEnv->GetStringUTFChars(resString[j * lenRow + i], &isCopy));
206                 }
207             }
208             else
209             {
210                 for (int j = 0; j < lenCol; j++)
211                 {
212                     resString[i * lenCol + j] = reinterpret_cast<jstring>(curEnv->GetObjectArrayElement(oneDim, j));
213                     addr[i * lenCol + j] = const_cast<char *>(curEnv->GetStringUTFChars(resString[i * lenCol + j], &isCopy));
214                 }
215             }
216             curEnv->DeleteLocalRef(oneDim);
217         }
218
219         SciErr err;
220         if (getMethodOfConv())
221         {
222             err = createMatrixOfString(pvApiCtx, pos, lenRow, lenCol, addr);
223         }
224         else
225         {
226             err = createMatrixOfString(pvApiCtx, pos, lenCol, lenRow, addr);
227         }
228
229         for (int i = 0; i < lenRow * lenCol; i++)
230         {
231             curEnv->ReleaseStringUTFChars(resString[i], addr[i]);
232             curEnv->DeleteLocalRef(resString[i]);
233         }
234         delete[] addr;
235         delete[] resString;
236
237         if (err.iErr)
238         {
239             throw org_scilab_modules_external_objects_java::NoMoreScilabMemoryException();
240         }
241
242         curEnv->DeleteLocalRef(res);
243         if (curEnv->ExceptionCheck())
244         {
245             throw GiwsException::JniCallMethodException(curEnv);
246         }
247     };
248 };