With release 1.3.0 of giws (fixes some various issues)
[scilab.git] / scilab / modules / commons / src / jni / GiwsException.hxx
1 /* Generated by GIWS (version 1.3.0) */
2 /*
3
4 Copyright 2007-2008 INRIA
5 Copyright 2008-2011 DIGITEO
6
7 Author : Sylvestre Ledru & others
8
9 This is generated code.
10
11 This software is a computer program whose purpose is to hide the complexity
12 of accessing Java objects/methods from C++ code.
13
14 This software is governed by the CeCILL-B license under French law and
15 abiding by the rules of distribution of free software.  You can  use, 
16 modify and/ or redistribute the software under the terms of the CeCILL-B
17 license as circulated by CEA, CNRS and INRIA at the following URL
18 "http://www.cecill.info". 
19
20 As a counterpart to the access to the source code and  rights to copy,
21 modify and redistribute granted by the license, users are provided only
22 with a limited warranty  and the software's author,  the holder of the
23 economic rights,  and the successive licensors  have only  limited
24 liability. 
25
26 In this respect, the user's attention is drawn to the risks associated
27 with loading,  using,  modifying and/or developing or reproducing the
28 software by the user in light of its specific status of free software,
29 that may mean  that it is complicated to manipulate,  and  that  also
30 therefore means  that it is reserved for developers  and  experienced
31 professionals having in-depth computer knowledge. Users are therefore
32 encouraged to load and test the software's suitability as regards their
33 requirements in conditions enabling the security of their systems and/or 
34 data to be ensured and,  more generally, to use and operate it in the 
35 same conditions as regards security. 
36
37 The fact that you are presently reading this means that you have had
38 knowledge of the CeCILL-B license and that you accept its terms.
39 */
40
41
42 #ifndef __GIWSEXCEPTION__
43 #define __GIWSEXCEPTION__
44 #include <iostream>
45 #include <string>
46 #include <string.h>
47 #include <stdlib.h>
48 #include <jni.h>
49
50 #ifndef _MSC_VER /* Defined anyway with Visual */
51 #if !defined(byte)
52 typedef signed char byte;
53 #else
54 #pragma message("Byte has been redefined elsewhere. Some problems can happen")
55 #endif
56 #endif
57 #include <exception>
58
59
60 #ifndef GIWSEXPORT
61 # if defined(_MSC_VER) || defined(__WIN32__) || defined(__CYGWIN__)
62 #   if defined(STATIC_LINKED)
63 #     define GIWSEXPORT
64 #   else
65 #     define GIWSEXPORT __declspec(dllexport)
66 #   endif
67 # else
68 #     define GIWSEXPORT
69 # endif
70 #endif
71
72
73 namespace GiwsException {
74
75
76
77 /**
78 * Parent class for exceptions which may occure in JNI code.
79 */
80 class GIWSEXPORT JniException : public std::exception
81 {
82
83 /** Error message to display */
84 std::string m_oErrorMessage;
85
86 /** Java description of the exception*/
87 std::string m_oJavaMessage;
88
89 /** Java stackTrace when the exception occured */
90 std::string m_oJavaStackTrace;
91
92 /** Name of the exception (ie class name).*/
93 std::string m_oJavaExceptionName;
94
95 /** The exception itself ... we store as a member otherwise JNI
96 complains about 'WARNING in native method: JNI call made with
97 exception pending' */
98 jthrowable javaException;
99
100 public:
101
102 /**
103 * Each subclass of JniExcpetion should call the super constructor
104 * and the setErrorMessage function to set the message.
105 * @param curEnv java environment where the exception occured.
106 */
107 JniException(JNIEnv * curEnv) throw() ;
108 JniException() throw() : exception() { };
109
110
111 virtual ~JniException(void) throw();
112
113 /**
114 * @return a description of the exception
115 * @deprecated This function could lead to side effect error. Please use whatStr
116 */
117 virtual const char * what(void) const throw();
118
119 /**
120 * @return a description of the exception
121 */
122 virtual std::string whatStr(void) const throw();
123
124 /**
125 * @return Java description of the exception.
126 */
127 std::string getJavaDescription(void) const throw();
128
129 /**
130 * @return Java stack trace where the exception occured.
131 */
132 std::string getJavaStackTrace(void) const throw();
133
134 /**
135 * Get the name of the exception (ie its class name).
136 */
137 std::string getJavaExceptionName(void) const throw();
138
139 protected:
140
141 /**
142 * Set the error message that the exception should print.
143 */
144 void setErrorMessage(const std::string & errorMessage);
145
146 /**
147 * Get the message that the exception will print.
148 */
149 std::string getErrorMessage(void) const;
150
151 private:
152   /**
153 * @return error message of the exception.
154 */
155 std::string retrieveExceptionMessage(JNIEnv * curEnv);
156 /**
157 * @return full stack trace when the exception occured.
158 */
159 std::string retrieveStackTrace(JNIEnv * curEnv);
160
161 /**
162 * @return string containing the name of the exception (ie its class name).
163 */
164 std::string retrieveExceptionName(JNIEnv * curEnv);
165 /**
166 * To be called when all the information about the exceptions have been
167 * retrived.
168 * Remove the exception from the environment.
169 */
170 void closeException(JNIEnv * curEnv);
171
172 /**
173 * Convert a Java string (jstring) into a C++ string
174 */
175 std::string convertJavaString(JNIEnv * curEnv, jstring javaString);
176 };
177
178 /**
179 * Exception that should be thrown when allocation of Java resources from C++
180 * code fails (sur as NewDoubleArray or NewStringUTF).
181 */
182 class GIWSEXPORT JniBadAllocException : public JniException
183 {
184 public:
185
186 JniBadAllocException(JNIEnv * curEnv) throw();
187 virtual ~JniBadAllocException(void) throw();
188 };
189
190 /**
191 * Exception that should be thrown when a call to a Java method
192 * using Jni throw an exception.
193 * If possible, user should try to avoid this sitution because of the loss
194 * of information.
195 */
196 class GIWSEXPORT JniCallMethodException : public JniException
197 {
198 public:
199
200   /**
201    * @param curEnv java envirnonment where the exception occured.
202    */
203   JniCallMethodException(JNIEnv * curEnv) throw();
204
205   virtual ~JniCallMethodException(void) throw();
206 };
207
208 /**
209 * Exception that should be thrown when Jni code could not find a Java class
210 */
211 class GIWSEXPORT JniClassNotFoundException : public JniException
212 {
213 public:
214
215 /**
216 * @param className name of the class which haven't been found
217 */
218 JniClassNotFoundException(JNIEnv * curEnv, const std::string & className) throw();
219
220 virtual ~JniClassNotFoundException(void) throw();
221
222 };
223
224 /**
225 * Exception that should be thrown when Jni code could not find a Java method
226 */
227 class GIWSEXPORT JniMethodNotFoundException : public JniException
228 {
229 public:
230
231 /**
232 * @param className name of the method which haven't been found
233 */
234 JniMethodNotFoundException(JNIEnv * curEnv, const std::string & methodName) throw();
235 virtual ~JniMethodNotFoundException(void) throw();
236
237 };
238
239 /**
240 * Exception that should be thrown when a call to a Java method
241 * using Jni throw an exception.
242 * If possible, user should try to avoid this sitution because of the loss
243 * of information.
244 */
245 class GIWSEXPORT JniObjectCreationException : public JniException
246 {
247 public:
248
249 /**
250 * @param curEnv java envirnonment where the exception occured.
251 */
252 JniObjectCreationException(JNIEnv * curEnv, const std::string & className) throw();
253 virtual ~JniObjectCreationException(void) throw();
254
255 };
256
257
258 /**
259 * Exception that should be thrown when a call to the Java monitor
260 * failed
261 */
262 class GIWSEXPORT JniMonitorException : public JniException
263 {
264 public:
265
266 /**
267 * @param curEnv java envirnonment where the exception occured.
268 */
269 JniMonitorException(JNIEnv * curEnv, const std::string & className) throw();
270 virtual ~JniMonitorException(void) throw();
271
272 };
273
274
275 }
276 #endif
277