0574af72cad3d01e307f4ebff9a2ea457dc09f4a
[scilab.git] / scilab / modules / history_browser / src / jni / GiwsException.hxx
1 /* Generated by GIWS (version 1.1.1) */
2 /*
3
4 Copyright 2007-2008 INRIA
5 Copyright 2008-2010 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 namespace GiwsException {
60
61
62 /**
63 * Parent class for exceptions which may occure in JNI code.
64 */
65 class JniException : public std::exception
66 {
67
68 /** Error message to display */
69 std::string m_oErrorMessage;
70
71 /** Java description of the exception*/
72 std::string m_oJavaMessage;
73
74 /** Java stackTrace when the exception occured */
75 std::string m_oJavaStackTrace;
76
77 /** Name of the exception (ie class name).*/
78 std::string m_oJavaExceptionName;
79
80 /** The exception itself ... we store as a member otherwise JNI
81 complains about 'WARNING in native method: JNI call made with
82 exception pending' */
83 jthrowable javaException;
84
85 public:
86
87 /**
88 * Each subclass of JniExcpetion should call the super constructor
89 * and the setErrorMessage function to set the message.
90 * @param curEnv java environment where the exception occured.
91 */
92 JniException(JNIEnv * curEnv) throw() ;
93
94 virtual ~JniException(void) throw();
95
96 /**
97 * @return a description of the exception
98 */
99 virtual const char * what(void) const throw();
100
101 /**
102 * @return Java description of the exception.
103 */
104 std::string getJavaDescription(void) const throw();
105
106 /**
107 * @return Java stack trace where the exception occured.
108 */
109 std::string getJavaStackTrace(void) const throw();
110
111 /**
112 * Get the name of the exception (ie its class name).
113 */
114 std::string getJavaExceptionName(void) const throw();
115
116 protected:
117
118 /**
119 * Set the error message that the exception should print.
120 */
121 void setErrorMessage(const std::string & errorMessage);
122
123 /**
124 * Get the message that the exception will print.
125 */
126 std::string getErrorMessage(void) const;
127
128 private:
129   /**
130 * @return error message of the exception.
131 */
132 std::string retrieveExceptionMessage(JNIEnv * curEnv);
133 /**
134 * @return full stack trace when the exception occured.
135 */
136 std::string retrieveStackTrace(JNIEnv * curEnv);
137
138 /**
139 * @return string containing the name of the exception (ie its class name).
140 */
141 std::string retrieveExceptionName(JNIEnv * curEnv);
142 /**
143 * To be called when all the information about the exceptions have been
144 * retrived.
145 * Remove the exception from the environment.
146 */
147 void closeException(JNIEnv * curEnv);
148
149 /**
150 * Convert a Java string (jstring) into a C++ string
151 */
152 std::string convertJavaString(JNIEnv * curEnv, jstring javaString);
153 };
154
155 /**
156 * Exception that should be thrown when allocation of Java resources from C++
157 * code fails (sur as NewDoubleArray or NewStringUTF).
158 */
159 class JniBadAllocException : public JniException
160 {
161 public:
162
163 JniBadAllocException(JNIEnv * curEnv) throw();
164 virtual ~JniBadAllocException(void) throw();
165 };
166
167 /**
168 * Exception that should be thrown when a call to a Java method
169 * using Jni throw an exception.
170 * If possible, user should try to avoid this sitution because of the loss
171 * of information.
172 */
173 class JniCallMethodException : public JniException
174 {
175 public:
176
177   /**
178    * @param curEnv java envirnonment where the exception occured.
179    */
180   JniCallMethodException(JNIEnv * curEnv) throw();
181
182   virtual ~JniCallMethodException(void) throw();
183 };
184
185 /**
186 * Exception that should be thrown when Jni code could not find a Java class
187 */
188 class JniClassNotFoundException : public JniException
189 {
190 public:
191
192 /**
193 * @param className name of the class which haven't been found
194 */
195 JniClassNotFoundException(JNIEnv * curEnv, const std::string & className) throw();
196
197 virtual ~JniClassNotFoundException(void) throw();
198
199 };
200
201 /**
202 * Exception that should be thrown when Jni code could not find a Java method
203 */
204 class JniMethodNotFoundException : public JniException
205 {
206 public:
207
208 /**
209 * @param className name of the method which haven't been found
210 */
211 JniMethodNotFoundException(JNIEnv * curEnv, const std::string & methodName) throw();
212 virtual ~JniMethodNotFoundException(void) throw();
213
214 };
215
216 /**
217 * Exception that should be thrown when a call to a Java method
218 * using Jni throw an exception.
219 * If possible, user should try to avoid this sitution because of the loss
220 * of information.
221 */
222 class JniObjectCreationException : public JniException
223 {
224 public:
225
226 /**
227 * @param curEnv java envirnonment where the exception occured.
228 */
229 JniObjectCreationException(JNIEnv * curEnv, const std::string & className) throw();
230 virtual ~JniObjectCreationException(void) throw();
231
232 };
233
234
235 /**
236 * Exception that should be thrown when a call to the Java monitor
237 * failed
238 */
239 class JniMonitorException : public JniException
240 {
241 public:
242
243 /**
244 * @param curEnv java envirnonment where the exception occured.
245 */
246 JniMonitorException(JNIEnv * curEnv, const std::string & className) throw();
247 virtual ~JniMonitorException(void) throw();
248
249 };
250
251
252 }
253 #endif
254