ad0659b4873332d5560c81040b497ace9b8e0fdc
[scilab.git] / scilab / modules / commons / src / jni / GiwsException.cpp
1 /* Generated by GIWS (version 2.0.1) */
2 /*
3
4 This is generated code.
5
6 This software is a computer program whose purpose is to hide the complexity
7 of accessing Java objects/methods from C++ code.
8
9 This software is governed by the CeCILL-B license under French law and
10 abiding by the rules of distribution of free software.  You can  use, 
11 modify and/ or redistribute the software under the terms of the CeCILL-B
12 license as circulated by CEA, CNRS and INRIA at the following URL
13 "http://www.cecill.info". 
14
15 As a counterpart to the access to the source code and  rights to copy,
16 modify and redistribute granted by the license, users are provided only
17 with a limited warranty  and the software's author,  the holder of the
18 economic rights,  and the successive licensors  have only  limited
19 liability. 
20
21 In this respect, the user's attention is drawn to the risks associated
22 with loading,  using,  modifying and/or developing or reproducing the
23 software by the user in light of its specific status of free software,
24 that may mean  that it is complicated to manipulate,  and  that  also
25 therefore means  that it is reserved for developers  and  experienced
26 professionals having in-depth computer knowledge. Users are therefore
27 encouraged to load and test the software's suitability as regards their
28 requirements in conditions enabling the security of their systems and/or 
29 data to be ensured and,  more generally, to use and operate it in the 
30 same conditions as regards security. 
31
32 The fact that you are presently reading this means that you have had
33 knowledge of the CeCILL-B license and that you accept its terms.
34 */
35
36 #include "GiwsException.hxx" 
37 namespace GiwsException {
38
39
40
41 /**
42 * Each subclass of JniExcpetion should call the super constructor
43 * and the setErrorMessage function to set the message.
44 * @param curEnv java envirnonment where the exception occured.
45 */
46 JniException::JniException(JNIEnv * curEnv) throw() : exception()
47 {
48 // retrieve information about the exception
49 javaException = curEnv->ExceptionOccurred();
50 /* Clear the Java Exception to avoid calling it again & again */
51 curEnv->ExceptionClear();
52 m_oJavaMessage = this->retrieveExceptionMessage(curEnv);
53 m_oJavaStackTrace = this->retrieveStackTrace(curEnv);
54 m_oJavaExceptionName = this->retrieveExceptionName(curEnv);
55
56 // by default JniExceptions display teh stack trace
57 setErrorMessage(m_oJavaMessage + "\n" + m_oJavaStackTrace);
58 curEnv->DeleteLocalRef(javaException);
59 closeException(curEnv);
60 }
61
62 JniException::~JniException(void) throw()
63 {
64 m_oErrorMessage.clear();
65 }
66
67 /**
68 * @return a description of the exception
69 * @deprecated This function could lead to side effect error. Please use whatStr
70 */
71 const char * JniException::what(void) const throw()
72 {
73 return m_oErrorMessage.c_str();
74 }
75
76 /**
77 * @return a description of the exception
78 */
79 std::string JniException::whatStr(void) const throw()
80 {
81 return m_oErrorMessage;
82 }
83
84 /**
85 * @return Java description of the exception.
86 */
87 std::string JniException::getJavaDescription(void) const throw()
88 {
89 return m_oJavaMessage;
90 }
91
92 /**
93 * @return Java stack trace where the exception occured.
94 */
95 std::string JniException::getJavaStackTrace(void) const throw()
96 {
97 return m_oJavaStackTrace;
98 }
99
100 /**
101 * Get the name of the exception (ie its class name).
102 */
103 std::string JniException::getJavaExceptionName(void) const throw()
104 {
105 return m_oJavaExceptionName;
106 }
107
108
109 /**
110 * Set the error message that the exception should print.
111 */
112 void JniException::setErrorMessage(const std::string & errorMessage)
113 {
114 m_oErrorMessage = errorMessage;
115 }
116
117 /**
118 * Get the message that the exception will print.
119 */
120 std::string JniException::getErrorMessage(void) const
121 {
122 return m_oErrorMessage;
123 }
124
125 /**
126 * @return error message of the exception.
127 */
128 std::string JniException::retrieveExceptionMessage(JNIEnv * curEnv)
129 {
130 // return the result of the getLocalizedMessage method
131
132 // retrieve information from the exception.
133 // get method id
134 jmethodID getLocalizedMessageId = curEnv->GetMethodID(curEnv->GetObjectClass(javaException),
135    "getLocalizedMessage",
136    "()Ljava/lang/String;");
137
138 // call getLocalizedMessage
139 jstring description = (jstring) curEnv->CallObjectMethod(javaException, getLocalizedMessageId);
140
141 if (description == NULL)
142 {
143   return "";
144 }
145
146 std::string res = convertJavaString(curEnv, description);
147
148 // release java resources
149 curEnv->DeleteLocalRef(description);
150
151 return res;
152   }
153
154   /**
155    * @return full stack trace when the exception occured.
156    */
157   std::string JniException::retrieveStackTrace(JNIEnv * curEnv)
158   {
159
160
161 // return the result of the getStackTrace method
162
163 // retrieve information from the exception.
164 // get method id
165 // getStackTrace returns an array of StackTraceElement
166 jmethodID getStackTraceId = curEnv->GetMethodID(curEnv->GetObjectClass(javaException),
167 "getStackTrace",
168 "()[Ljava/lang/StackTraceElement;");
169
170 // call getStackTrace
171 jobjectArray stackTrace = (jobjectArray) curEnv->CallObjectMethod(javaException, getStackTraceId);
172
173 if (stackTrace == NULL)
174 {
175   return "";
176 }
177
178 // get length of the array
179 jsize stackTraceLength = curEnv->GetArrayLength(stackTrace);
180 std::string res = "";
181
182 // get toString methodId of StackTraceElement class
183 jclass stackTraceElementClass = curEnv->FindClass("java/lang/StackTraceElement");
184 jmethodID toStringId = curEnv->GetMethodID(stackTraceElementClass, "toString", "()Ljava/lang/String;");
185
186 for (jsize i = 0; i < stackTraceLength; i++)
187 {
188   // add the result of toString method of each element in the result
189   jobject curStackTraceElement = curEnv->GetObjectArrayElement(stackTrace, i);
190
191   // call to string on the object
192   jstring stackElementString = (jstring) curEnv->CallObjectMethod(curStackTraceElement, toStringId);
193
194   if (stackElementString == NULL)
195   {
196 curEnv->DeleteLocalRef(stackTraceElementClass);
197 curEnv->DeleteLocalRef(stackTrace);
198 curEnv->DeleteLocalRef(curStackTraceElement);
199 return res;
200   }
201
202   // add a line to res
203   res += " at " + convertJavaString(curEnv, stackElementString) + "\n";
204
205   curEnv->DeleteLocalRef(curStackTraceElement);
206   curEnv->DeleteLocalRef(stackElementString);
207 }
208
209 // release java resources
210 curEnv->DeleteLocalRef(stackTraceElementClass);
211 curEnv->DeleteLocalRef(stackTrace);
212
213
214 return res;
215   }
216
217   /**
218    * @return string containing the name of the exception (ie its class name).
219    */
220   std::string JniException::retrieveExceptionName(JNIEnv * curEnv)
221   {
222
223 // then get its class
224 jclass exceptionClass = curEnv->GetObjectClass(javaException);
225
226 // get the Class class
227 // we could also use curEnv->FindClass("Class");
228 jclass classClass = curEnv->GetObjectClass(exceptionClass);
229
230 // get the getName method
231 jmethodID getNameId = curEnv->GetMethodID(classClass, "getName", "()Ljava/lang/String;");
232
233 // call the getName function
234 jstring javaName = (jstring) curEnv->CallObjectMethod(exceptionClass, getNameId);
235
236 if (javaName == NULL)
237 {
238   return "";
239 }
240
241 std::string res = convertJavaString(curEnv, javaName);
242
243 // release java resources
244 curEnv->DeleteLocalRef(exceptionClass);
245 curEnv->DeleteLocalRef(classClass);
246 curEnv->DeleteLocalRef(javaName);
247
248 return res;
249   }
250
251   /**
252    * To be called when all the information about the exceptions have been
253    * retrived.
254    * Remove the exception from the environment.
255    */
256   void JniException::closeException(JNIEnv * curEnv)
257   {
258 // remove the exception from the environment
259 // Beware, the exception is no longer reachable
260 curEnv->ExceptionClear();
261   }
262
263   /**
264    * Convert a Java string (jstring) into a C++ string
265    */
266   std::string JniException::convertJavaString(JNIEnv * curEnv, jstring javaString)
267   {
268 // get a pointer on a C string
269 const char * tempString = curEnv->GetStringUTFChars(javaString, 0);
270
271 // convert the C string into a C++ string
272 std::string res(tempString);
273
274 // release pointer
275 curEnv->ReleaseStringUTFChars(javaString, tempString);
276
277 return res;
278   }
279
280
281   /**
282   * Exception that should be thrown when allocation of Java resources from C++
283   * code fails (sur as NewDoubleArray or NewStringUTF).
284   */
285   
286   JniBadAllocException::JniBadAllocException(JNIEnv * curEnv) throw() : JniException()
287   {
288   std::string message = "Error no more memory.";
289   setErrorMessage(message);
290   }
291   
292   JniBadAllocException::~JniBadAllocException(void) throw() {}
293
294
295   /**
296   * Exception that should be thrown when a call to a Java method
297   * using Jni throw an exception.
298   * If possible, user should try to avoid this sitution because of the loss
299   * of information.
300   */
301   
302   /**
303   * @param curEnv java environment where the exception occured.
304   */
305   JniCallMethodException::JniCallMethodException(JNIEnv * curEnv) throw() : JniException(curEnv)
306   {
307   std::string errorMessage = "Exception when calling Java method : ";
308   errorMessage += getJavaDescription() + "\n" + getJavaStackTrace();
309   errorMessage += what();
310   setErrorMessage(errorMessage);
311   }
312   
313   JniCallMethodException::~JniCallMethodException(void) throw() {}
314   /**
315   * @param className name of the class which haven't been found
316   */
317   JniClassNotFoundException::JniClassNotFoundException(JNIEnv * curEnv, const std::string & className) throw() : JniException(curEnv)
318   {
319 std::string errorMessage = "Could not get the Class " + className + ".";
320 setErrorMessage(errorMessage);
321   }
322
323   JniClassNotFoundException::~JniClassNotFoundException(void) throw() {}
324
325   /**
326    * @param className name of the method which haven't been found
327    */
328   JniMethodNotFoundException::JniMethodNotFoundException(JNIEnv * curEnv, const std::string & methodName) throw() : JniException(curEnv)
329   {
330 std::string errorMessage = "Could not access to the method " + methodName + ".";
331 setErrorMessage(errorMessage);
332   }
333
334   JniMethodNotFoundException::~JniMethodNotFoundException(void) throw() {}
335   
336   /**
337    * @param curEnv java envirnonment where the exception occured.
338    */
339   JniObjectCreationException::JniObjectCreationException(JNIEnv * curEnv, const std::string & className) throw() : JniException(curEnv)
340   {
341 std::string errorMessage = "Could not instantiate the object " + className + ".";
342 setErrorMessage(errorMessage);
343   }
344
345   JniObjectCreationException::~JniObjectCreationException(void) throw() {}
346
347   /**
348    * @param curEnv java envirnonment where the exception occured.
349    */
350   JniMonitorException::JniMonitorException(JNIEnv * curEnv, const std::string & className) throw() : JniException(curEnv)
351   {
352 std::string errorMessage = "Error in the access (Enter or exit) or a Java env monitor of class " + className + ".";
353 setErrorMessage(errorMessage);
354   }
355
356   JniMonitorException::~JniMonitorException(void) throw() {}
357
358
359
360 }
361