1 karl 1.34 //%2006////////////////////////////////////////////////////////////////////////
|
2 schuur 1.1 //
|
3 karl 1.10 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
|
6 schuur 1.1 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.10 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
|
9 karl 1.12 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 karl 1.34 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
|
13 schuur 1.1 //
14 // Permission is hereby granted, free of charge, to any person obtaining a copy
15 // of this software and associated documentation files (the "Software"), to
16 // deal in the Software without restriction, including without limitation the
17 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
18 // sell copies of the Software, and to permit persons to whom the Software is
19 // furnished to do so, subject to the following conditions:
|
20 mark.hamzy 1.36 //
|
21 schuur 1.1 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
22 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
23 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
24 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
25 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
27 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30 //==============================================================================
31 //
32 //%/////////////////////////////////////////////////////////////////////////////
|
33 mark.hamzy 1.57
|
34 schuur 1.1 #include "JMPIImpl.h"
35
|
36 a.dunfey 1.65 #if defined(PEGASUS_OS_TYPE_WINDOWS)
|
37 konrad.r 1.14 #include <Pegasus/Common/DynamicLibrary.h>
38 #else
|
39 schuur 1.1 #include <dlfcn.h>
|
40 konrad.r 1.14 #endif
|
41 schuur 1.1 #include <iostream>
|
42 mark.hamzy 1.16 #include <sstream>
|
43 schuur 1.1
44 #include <Pegasus/Common/Config.h>
45 #include <Pegasus/Common/System.h>
46 #include <Pegasus/Common/CIMClass.h>
47 #include <Pegasus/Common/CIMInstance.h>
48 #include <Pegasus/Common/CIMObjectPath.h>
49 #include <Pegasus/Common/CIMProperty.h>
50 #include <Pegasus/Common/OperationContext.h>
51 #include <Pegasus/Provider/CIMOMHandle.h>
52 #include <Pegasus/Client/CIMClient.h>
|
53 schuur 1.3 #include <Pegasus/ProviderManager2/JMPI/JMPIProviderManager.h>
|
54 mark.hamzy 1.42 #include <Pegasus/WQL/WQLSelectStatement.h>
55 #include <Pegasus/WQL/WQLParser.h>
56 #define CALL_SIGN_WQL "WQL"
|
57 schuur 1.1
58 PEGASUS_USING_STD;
59 PEGASUS_NAMESPACE_BEGIN
60
61 JavaVM *JMPIjvm::jvm=NULL;
62 JvmVector JMPIjvm::jv;
|
63 schuur 1.2 int JMPIjvm::trace=0;
|
64 schuur 1.1
|
65 mark.hamzy 1.26 #ifdef PEGASUS_DEBUG
|
66 mark.hamzy 1.16 #define DDD(x) if (JMPIjvm::trace) x;
|
67 mark.hamzy 1.26 #else
68 #define DDD(x)
69 #endif
|
70 mark.hamzy 1.16
|
71 mark.hamzy 1.20 #include "Convert.h"
72
|
73 mark.hamzy 1.17 JMPIjvm::ClassTable JMPIjvm::_classTable;
74 JMPIjvm::ObjectTable JMPIjvm::_objectTable;
75
|
76 schuur 1.1 const char* classNames[]={
|
77 mark.hamzy 1.26 /*00*/ "java/util/Vector" ,
78 /*01*/ "java/lang/Boolean",
79 /*02*/ "java/lang/Byte",
80 /*03*/ "java/lang/Short",
81 /*04*/ "java/lang/Integer",
82 /*05*/ "java/lang/Long",
83 /*06*/ "java/lang/Float",
84 /*07*/ "java/lang/Double",
85 /*08*/ "org/pegasus/jmpi/UnsignedInt8",
86 /*09*/ "org/pegasus/jmpi/UnsignedInt16",
87 /*10*/ "org/pegasus/jmpi/UnsignedInt32",
88 /*11*/ "org/pegasus/jmpi/UnsignedInt64",
89 /*12*/ "org/pegasus/jmpi/CIMObjectPath",
90 /*13*/ "org/pegasus/jmpi/CIMException",
91 /*14*/ "java/math/BigInteger",
92 /*15*/ "org/pegasus/jmpi/CIMProperty",
93 /*16*/ "org/pegasus/jmpi/CIMOMHandle",
94 /*17*/ "org/pegasus/jmpi/CIMClass",
95 /*18*/ "org/pegasus/jmpi/CIMInstance",
96 /*19*/ "org/pegasus/jmpi/CIMValue",
97 /*20*/ "java/lang/Object",
98 mark.hamzy 1.26 /*21*/ "java/lang/Throwable",
99 /*22*/ "java/lang/String",
100 /*23*/ "org/pegasus/jmpi/JarClassLoader",
101 /*24*/ "org/pegasus/jmpi/CIMDateTime",
102 /*25*/ "org/pegasus/jmpi/SelectExp",
103 /*26*/ "org/pegasus/jmpi/CIMQualifier",
104 /*27*/ "org/pegasus/jmpi/CIMQualifierType",
105 /*28*/ "org/pegasus/jmpi/CIMFlavor",
106 /*29*/ "org/pegasus/jmpi/CIMArgument",
107 /*30*/ "org/pegasus/jmpi/CIMInstanceException",
|
108 mark.hamzy 1.35 /*31*/ "org/pegasus/jmpi/CIMObject",
109 /*32*/ "java/lang/Character",
|
110 mark.hamzy 1.36 /*33*/ "org/pegasus/jmpi/OperationContext",
111 /*34*/ "java/lang/Class",
|
112 schuur 1.1 };
113
114 const METHOD_STRUCT instanceMethodNames[]={
|
115 mark.hamzy 1.36 /*00 VectorNew */ { /*Vector */ 0, "<init>", "()V" },
116 /*01 BooleanNewZ */ { /*Boolean */ 1, "<init>", "(Z)V" },
117 /*02 ByteNewB */ { /*Byte */ 2, "<init>", "(B)V" },
118 /*03 ShortNewS */ { /*Short */ 3, "<init>", "(S)V" },
119 /*04 IntegerNewI */ { /*Integer */ 4, "<init>", "(I)V" },
120 /*05 LongNewJ */ { /*Long */ 5, "<init>", "(J)V" },
121 /*06 FloatNewF */ { /*Float */ 6, "<init>", "(F)V" },
122 /*07 DoubleNewD */ { /*Double */ 7, "<init>", "(D)V" },
123 /*08 UnsignedInt8NewS */ { /*UnsignedInt8 */ 8, "<init>", "(S)V" },
124 /*09 UnsignedInt16NewI */ { /*UnsignedInt16 */ 9, "<init>", "(I)V" },
125 /*10 UnsignedInt32NewJ */ { /*UnsignedInt32 */10, "<init>", "(J)V" },
126 /*11 UnsignedInt64NewBi */ { /*UnsignedInt64 */11, "<init>", "(Ljava/math/BigInteger;)V" },
|
127 mark.hamzy 1.61 /*12 CIMObjectPathNewJ */ { /*CIMObjectPath */12, "<init>", "(J)V" },
|
128 mark.hamzy 1.36 /*13 CIMExceptionNewSt */ { /*CIMException */13, "<init>", "(Ljava/lang/String;)V" },
|
129 mark.hamzy 1.61 /*14 CIMPropertyNewJ */ { /*CIMProperty */15, "<init>", "(J)V" },
|
130 mark.hamzy 1.36 /*15 VectorAddElement */ { /*Vector */ 0, "addElement", "(Ljava/lang/Object;)V" },
131 /*16 VectorElementAt */ { /*Vector */ 0, "elementAt", "(I)Ljava/lang/Object;" },
|
132 mark.hamzy 1.61 /*17 CIMOMHandleNewJSt */ { /*CIMOMHandle */16, "<init>", "(JLjava/lang/String;)V" },
|
133 mark.hamzy 1.36 /*18 CIMExceptionNewI */ { /*CIMException */13, "<init>", "(I)V" },
|
134 mark.hamzy 1.61 /*19 CIMClassNewJ */ { /*CIMClass */17, "<init>", "(J)V" },
135 /*20 CIMInstanceNewJ */ { /*CIMInstance */18, "<init>", "(J)V" },
136 /*21 CIMObjectPathCInst */ { /*CIMObjectPath */12, "cInst", "()J" },
137 /*22 CIMInstanceCInst */ { /*CIMInstance */18, "cInst", "()J" },
138 /*23 CIMClassCInst */ { /*CIMClass */17, "cInst", "()J" },
|
139 mark.hamzy 1.36 /*24 ObjectToString */ { /*Object */20, "toString", "()Ljava/lang/String;" },
140 /*25 ThrowableGetMessage */ { /*Throwable */21, "getMessage", "()Ljava/lang/String;" },
141 /*26 CIMExceptionGetID */ { /*CIMException */13, "getID", "()Ljava/lang/String;" },
142 /*27 VectorSize */ { /*Vector */ 0, "size", "()I" },
|
143 mark.hamzy 1.61 /*28 CIMPropertyCInst */ { /*CIMProperty */15, "cInst", "()J" },
|
144 mark.hamzy 1.36 /*29 CIMOMHandleGetClass */ { /*CIMOMHandle */16, "getClass", "(Lorg/pegasus/jmpi/CIMObjectPath;Z)Lorg/pegasus/jmpi/CIMClass;" },
145 /*30 VectorRemoveElementAt */ { /*Vector */ 0, "removeElementAt", "(I)V" },
|
146 mark.hamzy 1.61 /*31 CIMValueCInst */ { /*CIMValue */19, "cInst", "()J" },
|
147 mark.hamzy 1.36 /*32 CIMExceptionNewISt */ { /*CIMException */13, "<init>", "(ILjava/lang/String;)V" },
148 /*33 CIMExceptionGetCode */ { /*CIMException */13, "getCode", "()I" },
|
149 mark.hamzy 1.61 /*34 CIMDateTimeNewJ */ { /*CIMDateTime */24, "<init>", "(J)V" },
150 /*35 SelectExpNewJ */ { /*SelectExp */25, "<init>", "(J)V" },
151 /*36 CIMQualifierNewJ */ { /*CIMQualifier */26, "<init>", "(J)V" },
|
152 mark.hamzy 1.36 /*37 CIMFlavorNewI */ { /*CIMFlavor */28, "<init>", "(I)V" },
153 /*38 CIMFlavorGetFlavor */ { /*CIMFlavor */28, "getFlavor", "()I" },
|
154 mark.hamzy 1.61 /*39 CIMArgumentCInst */ { /*CIMArgument */29, "cInst", "()J" },
155 /*40 CIMArgumentNewJ */ { /*CIMArgument */29, "<init>", "(J)V" },
|
156 mark.hamzy 1.36 /*41 CIMExceptionNew */ { /*CIMException */13, "<init>", "()V" },
157 /*42 CIMExceptionNewStOb */ { /*CIMException */13, "<init>", "(Ljava/lang/String;Ljava/lang/Object;)V" },
158 /*43 CIMExceptionNewStObOb */ { /*CIMException */13, "<init>", "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)V" },
159 /*44 CIMExceptionNewStObObOb */ { /*CIMException */13, "<init>", "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V" },
|
160 mark.hamzy 1.61 /*45 CIMValueNewJ */ { /*CIMValue */19, "<init>", "(J)V" },
161 /*46 CIMObjectNewJZ */ { /*CIMObject */31, "<init>", "(JZ)V" },
|
162 mark.hamzy 1.36 /*47 CharacterNewC */ { /*Character */32, "<init>", "(C)V" },
|
163 mark.hamzy 1.61 /*48 OperationContextNewJ */ { /*OperationContext */33, "<init>", "(J)V" },
|
164 mark.hamzy 1.36 /*49 OperationContextUnassociate */ { /*OperationContext */33, "unassociate", "()V" },
165 /*50 ClassGetInterfaces */ { /*Class */34, "getInterfaces", "()[Ljava/lang/Class;" },
166 /*51 ClassGetName */ { /*Class */34, "getName", "()Ljava/lang/String;" },
|
167 mark.hamzy 1.56 /*52 UnsignedInt64NewStr */ { /*UnsignedInt64 */11, "<init>", "(Ljava/lang/String;)V" }
|
168 schuur 1.1 };
169
170 const METHOD_STRUCT staticMethodNames[]={
|
171 mark.hamzy 1.26 /*00*/ { 14, "valueOf", "(J)Ljava/math/BigInteger;" },
172 /*01*/ { 23, "load", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Class;" },
|
173 schuur 1.1 };
174
175 static int methodInitDone=0;
176
|
177 mark.hamzy 1.26 jclass classRefs[sizeof(classNames)/sizeof(classNames[0])];
178 jmethodID instanceMethodIDs[sizeof(instanceMethodNames)/sizeof(instanceMethodNames[0])];
179 jmethodID staticMethodIDs[sizeof(staticMethodNames)/sizeof(staticMethodNames[0])];
|
180 mark.hamzy 1.20
|
181 mark.hamzy 1.26 jclass JMPIjvm::getGlobalClassRef(JNIEnv *env, const char* name)
182 {
|
183 mark.hamzy 1.44 jclass localRefCls = env->FindClass(name);
|
184 mark.hamzy 1.16
|
185 mark.hamzy 1.44 if (localRefCls == NULL)
|
186 mark.hamzy 1.16 return JNI_FALSE;
187
|
188 mark.hamzy 1.44 jclass globalRefCls = (jclass) env->NewGlobalRef(localRefCls);
|
189 mark.hamzy 1.16
|
190 mark.hamzy 1.28 #if 0
191 jmethodID jmidToString = env->GetMethodID(globalRefCls, "toString", "()Ljava/lang/String;");
192 jstring jstringResult = (jstring)env->CallObjectMethod(globalRefCls, jmidToString);
193 const char *pszResult = env->GetStringUTFChars(jstringResult, 0);
194
|
195 mark.hamzy 1.61 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getGlobalClassRef: globalRefCls = "<<PEGASUS_STD(hex)<<(long)globalRefCls<<PEGASUS_STD(dec)<<", name = "<<name<<", pszResult = "<<pszResult<<PEGASUS_STD(endl));
|
196 mark.hamzy 1.28
197 env->ReleaseStringUTFChars (jstringResult, pszResult);
198 #else
|
199 mark.hamzy 1.61 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getGlobalClassRef: globalRefCls = "<<PEGASUS_STD(hex)<<(long)globalRefCls<<PEGASUS_STD(dec)<<", name = "<<name<<PEGASUS_STD(endl));
|
200 mark.hamzy 1.28 #endif
201
|
202 schuur 1.1 env->DeleteLocalRef(localRefCls);
|
203 mark.hamzy 1.16
|
204 schuur 1.1 return globalRefCls;
205 }
206
|
207 mark.hamzy 1.26 JMPIjvm::JMPIjvm()
208 {
|
209 mark.hamzy 1.32 initJVM ();
|
210 schuur 1.1 }
211
|
212 mark.hamzy 1.26 JMPIjvm::~JMPIjvm()
213 {
|
214 schuur 1.1 }
215
|
216 mark.hamzy 1.26 int JMPIjvm::cacheIDs(JNIEnv *env)
217 {
|
218 mark.hamzy 1.44 if (methodInitDone == 1)
|
219 mark.hamzy 1.16 return JNI_TRUE;
|
220 mark.hamzy 1.44 if (methodInitDone == -1)
|
221 mark.hamzy 1.16 return JNI_FALSE;
|
222 schuur 1.1
|
223 mark.hamzy 1.41 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): enter"<<PEGASUS_STD(endl));
224
|
225 mark.hamzy 1.44 methodInitDone = -1;
|
226 mark.hamzy 1.16
|
227 mark.hamzy 1.44 for (unsigned i = 0; i<(sizeof(classNames)/sizeof(classNames[0])); i++)
228 {
|
229 mark.hamzy 1.16 //////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<classNames[i]<<PEGASUS_STD(endl));
|
230 mark.hamzy 1.44 if ((classRefs[i] = getGlobalClassRef(env,classNames[i])) == NULL)
|
231 mark.hamzy 1.16 {
232 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error: Count not find global class ref for "<<classNames[i]<<PEGASUS_STD(endl));
233
234 return JNI_FALSE;
235 }
|
236 schuur 1.1 }
|
237 schuur 1.7
|
238 mark.hamzy 1.44 for (unsigned j = 0; j<(sizeof(instanceMethodNames)/sizeof(instanceMethodNames[0])); j++)
239 {
|
240 mark.hamzy 1.28 //////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<j<<": "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<": "<<instanceMethodNames[j].signature<<PEGASUS_STD(endl));
|
241 mark.hamzy 1.44 if ((instanceMethodIDs[j] = env->GetMethodID(classRefs[instanceMethodNames[j].clsIndex],
|
242 mark.hamzy 1.28 instanceMethodNames[j].methodName,
|
243 mark.hamzy 1.44 instanceMethodNames[j].signature)) == NULL)
|
244 mark.hamzy 1.16 {
245 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error could not get method id for "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<PEGASUS_STD(endl));
|
246 schuur 1.1 return 0;
|
247 mark.hamzy 1.17 }
|
248 mark.hamzy 1.16 }
|
249 schuur 1.1
|
250 mark.hamzy 1.44 for (unsigned k = 0; k<(sizeof(staticMethodNames)/sizeof(staticMethodNames[0])); k++)
251 {
|
252 mark.hamzy 1.28 //////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<k<<": "<<classNames[staticMethodNames[k].clsIndex]<<": "<<staticMethodNames[k].methodName<<": "<<staticMethodNames[k].signature<<PEGASUS_STD(endl));
|
253 mark.hamzy 1.44 if ((staticMethodIDs[k] = env->GetStaticMethodID(classRefs[staticMethodNames[k].clsIndex],
|
254 mark.hamzy 1.28 staticMethodNames[k].methodName,
|
255 mark.hamzy 1.44 staticMethodNames[k].signature)) == NULL)
|
256 mark.hamzy 1.16 {
257 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error could not get method id for "<<classNames[staticMethodNames[k].clsIndex]<<": "<<staticMethodNames[k].methodName<<PEGASUS_STD(endl));
258 return 0;
259 }
260 }
261
262 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): exit"<<PEGASUS_STD(endl));
263
|
264 mark.hamzy 1.44 jv.env = env;
265 jv.classRefs = classRefs;
266 jv.instMethodIDs = instanceMethodIDs;
267 jv.staticMethodIDs = staticMethodIDs;
268 jv.instanceMethodNames = instanceMethodNames;
|
269 mark.hamzy 1.30
|
270 mark.hamzy 1.44 methodInitDone = 1;
|
271 mark.hamzy 1.16
|
272 schuur 1.1 return JNI_TRUE;
273 }
274
|
275 mark.hamzy 1.62 static void throwCIMException (JNIEnv *env, char *e)
|
276 mark.hamzy 1.26 {
|
277 mark.hamzy 1.62 JMPIjvm::cacheIDs (env);
|
278 mark.hamzy 1.30
|
279 mark.hamzy 1.62 env->ThrowNew (JMPIjvm::jv.CIMExceptionClassRef, e);
|
280 schuur 1.1 }
281
|
282 mark.hamzy 1.62 int JMPIjvm::destroyJVM ()
|
283 schuur 1.3 {
|
284 mark.hamzy 1.16 DDD(PEGASUS_STD(cerr)<<"--- JPIjvm::destroyJVM()"<<PEGASUS_STD(endl));
285
|
286 mark.hamzy 1.26 #ifdef JAVA_DESTROY_VM_WORKS
|
287 mark.hamzy 1.44 if (jvm!= NULL)
288 {
|
289 schuur 1.3 JvmVector *jv;
|
290 mark.hamzy 1.26
|
291 schuur 1.3 attachThread(&jv);
|
292 mark.hamzy 1.32
|
293 schuur 1.3 jvm->DestroyJavaVM();
|
294 mark.hamzy 1.26
295 jvm = NULL;
296
|
297 schuur 1.3 return 0;
298 }
|
299 mark.hamzy 1.26 #endif
|
300 mark.hamzy 1.16
|
301 schuur 1.3 return -1;
302 }
303
|
304 mark.hamzy 1.32 Mutex JMPIjvm::_initMutex;
305
306 int JMPIjvm::initJVM ()
|
307 schuur 1.1 {
|
308 mark.hamzy 1.32 AutoMutex lock (_initMutex);
309
310 if (jvm != NULL)
311 {
312 return 0;
313 }
314
|
315 schuur 1.1 JavaVMInitArgs vm_args;
316 jint res;
|
317 mark.hamzy 1.16 char *envstring;
|
318 schuur 1.1 JNIEnv *env;
|
319 mark.hamzy 1.16 JavaVMOption *poptions = 0;
320 int maxoption = 0;
|
321 mark.hamzy 1.29 typedef struct _JVMOptions {
322 const char *pszEnvName;
323 const char *pszPrefix;
324 bool fSplit;
325 } JVMOPTIONS;
|
326 mark.hamzy 1.16 Array<std::string> JNIoptions;
|
327 mark.hamzy 1.29 static JVMOPTIONS aEnvOptions[] = {
|
328 mark.hamzy 1.45 { "CLASSPATH", "-Djava.class.path=", false },
|
329 mark.hamzy 1.29 { "PEGASUS_JMPI_MAX_HEAP", "-Xmx" , false },
330 { "PEGASUS_JMPI_INITIAL_HEAP", "-Xms" , false },
331 { "PEGASUS_JMPI_JAVA_THREAD_STACK_SIZE", "-Xss" , false },
332 { "PEGASUS_JMPI_VERBOSE", "-verbose:" , true }
|
333 mark.hamzy 1.16 };
334 std::ostringstream oss;
|
335 schuur 1.9
336 #ifdef PEGASUS_DEBUG
|
337 mark.hamzy 1.44 if (getenv("PEGASUS_JMPI_TRACE"))
338 JMPIjvm::trace = 1;
339 else
340 JMPIjvm::trace = 0;
|
341 schuur 1.9 #else
|
342 mark.hamzy 1.44 JMPIjvm::trace = 0;
|
343 schuur 1.9 #endif
|
344 schuur 1.2
|
345 mark.hamzy 1.16 DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM()" << PEGASUS_STD(endl));
346
|
347 mark.hamzy 1.44 jv.initRc = 0;
|
348 schuur 1.1
|
349 mark.hamzy 1.44 envstring = getenv("CLASSPATH");
350 if (envstring == NULL)
351 {
352 jv.initRc = 1;
|
353 mark.hamzy 1.16
354 DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): No CLASSPATH environment variable found" << PEGASUS_STD(endl));
355
|
356 marek 1.47 throw PEGASUS_CIM_EXCEPTION_L(
357 CIM_ERR_FAILED,
358 MessageLoaderParms(
|
359 thilo.boehm 1.64 "ProviderManager2.JMPI.JMPIImpl.GET_CLASSPATH_FAILED.STANDARD",
|
360 marek 1.47 "Could not get CLASSPATH from environment.")
361 );
|
362 thilo.boehm 1.68
|
363 mark.hamzy 1.16 return -1;
364 }
365
|
366 mark.hamzy 1.62 ///JNIoptions.append ("-Djava.compiler=NONE");
|
367 mark.hamzy 1.20 ///maxoption++;
368
|
369 mark.hamzy 1.29 for (Uint32 i = 0; i < (int)(sizeof (aEnvOptions)/sizeof (aEnvOptions[0])); i++)
|
370 mark.hamzy 1.16 {
|
371 mark.hamzy 1.29 JVMOPTIONS *pEnvOption = &aEnvOptions[i];
|
372 mark.hamzy 1.16
|
373 mark.hamzy 1.29 envstring = getenv (pEnvOption->pszEnvName);
|
374 mark.hamzy 1.16 if (envstring)
375 {
|
376 mark.hamzy 1.29 if (pEnvOption->fSplit)
377 {
378 bool fCommaFound = true;
379 string stringValues = envstring;
380 string::size_type posStart = 0;
381 string::size_type posEnd = stringValues.length () - 1;
382
383 while (fCommaFound)
384 {
385 string stringValue;
386 string::size_type posComma = stringValues.find (',', posStart);
387
388 if (posComma != string::npos)
389 {
390 fCommaFound = true;
391 stringValue = stringValues.substr (posStart, posComma);
392 posStart = posComma + 1;
393 }
394 else
395 {
396 fCommaFound = false;
397 mark.hamzy 1.29 stringValue = stringValues.substr (posStart, posEnd - posStart + 1);
398 }
399
400 DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): fCommaFound = " << fCommaFound << ", posStart = " << posStart << ", posComma = " << posComma << ", posEnd = " << posEnd << "" << PEGASUS_STD(endl));
401
402 maxoption++;
403
404 oss.str ("");
405 oss << pEnvOption->pszPrefix << stringValue;
406
407 JNIoptions.append (oss.str ());
408
409 DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): " << pEnvOption->pszEnvName << " found! Specifying \"" << oss.str () << "\"" << PEGASUS_STD(endl));
410 }
411 }
412 else
413 {
414 maxoption++;
|
415 mark.hamzy 1.16
|
416 mark.hamzy 1.29 oss.str ("");
417 oss << pEnvOption->pszPrefix << envstring;
|
418 mark.hamzy 1.16
|
419 mark.hamzy 1.29 JNIoptions.append (oss.str ());
|
420 mark.hamzy 1.16
|
421 mark.hamzy 1.29 DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): " << pEnvOption->pszEnvName << " found! Specifying \"" << oss.str () << "\"" << PEGASUS_STD(endl));
422 }
|
423 mark.hamzy 1.16 }
424 }
425
426 poptions = (JavaVMOption *)calloc (maxoption, sizeof (JavaVMOption));
427 if (!poptions)
428 {
|
429 mark.hamzy 1.44 jv.initRc = 1;
|
430 mark.hamzy 1.16
431 DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): Could not allocate " << maxoption << " structures of size " << sizeof (JavaVMOption) << PEGASUS_STD(endl));
432
|
433 schuur 1.1 return -1;
434 }
435
|
436 mark.hamzy 1.44 for (Uint32 i = 0; i < JNIoptions.size(); i++)
|
437 mark.hamzy 1.16 {
438 poptions[i].optionString = (char *)JNIoptions[i].c_str ();
439
440 DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): Setting option " << i << " to \"" << poptions[i].optionString << "\"" << PEGASUS_STD(endl));
441 }
442
|
443 mark.hamzy 1.44 vm_args.version = JNI_VERSION_1_2;
444 vm_args.options = poptions;
445 vm_args.nOptions = maxoption;
446 vm_args.ignoreUnrecognized = JNI_TRUE;
|
447 schuur 1.1
|
448 mark.hamzy 1.44 res = JNI_CreateJavaVM(&jvm,(void**)&env,&vm_args);
|
449 mark.hamzy 1.16
450 if (poptions)
451 {
452 free (poptions);
453 }
454
|
455 mark.hamzy 1.44 if (res!= 0)
456 {
457 jv.initRc = 1;
|
458 mark.hamzy 1.32
|
459 mark.hamzy 1.16 DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): Can not create Java VM"<<PEGASUS_STD(endl));
460
|
461 mark.hamzy 1.32 return -1;
|
462 schuur 1.1 }
463
|
464 mark.hamzy 1.30 cacheIDs(env);
|
465 schuur 1.1
|
466 mark.hamzy 1.44 if (env->ExceptionOccurred())
467 {
468 jv.initRc = 1;
|
469 mark.hamzy 1.32
|
470 schuur 1.1 env->ExceptionDescribe();
|
471 mark.hamzy 1.32
472 #ifdef JAVA_DESTROY_VM_WORKS
473
474 JvmVector *jv = NULL;
475
476 attachThread (&jv);
477
478 jvm->DestroyJavaVM ();
479
480 jvm = NULL;
481 #endif
482
483 return -1;
|
484 schuur 1.1 }
485
|
486 mark.hamzy 1.44 jv.initRc = 1;
487 jv.jvm = jvm;
|
488 mark.hamzy 1.32
|
489 schuur 1.1 return res;
490 }
491
|
492 mark.hamzy 1.62 JNIEnv* JMPIjvm::attachThread (JvmVector **jvp)
|
493 mark.hamzy 1.32 {
494 JNIEnv* env = NULL;
|
495 marek 1.47 int rc;
|
496 mark.hamzy 1.32
497 if (jvm == NULL)
498 {
|
499 marek 1.47 rc = initJVM ();
|
500 mark.hamzy 1.32
|
501 marek 1.47 if ((jvm == NULL) || (rc != 0))
|
502 mark.hamzy 1.32 return NULL;
503 }
504
505 jvm->AttachCurrentThread ((void**)&env,NULL);
506
|
507 mark.hamzy 1.44 *jvp = &jv;
|
508 mark.hamzy 1.32
|
509 schuur 1.1 return env;
510 }
511
|
512 mark.hamzy 1.62 void JMPIjvm::detachThread ()
|
513 mark.hamzy 1.26 {
|
514 mark.hamzy 1.62 jvm->DetachCurrentThread ();
|
515 schuur 1.1 }
516
|
517 mark.hamzy 1.57 jobject JMPIjvm::getProvider (JNIEnv *env,
518 String jarName,
519 String className,
520 const char *pszProviderName,
521 jclass *pjClass)
522 {
523 jobject jProviderInstance = 0;
524 jclass jClassLoaded = 0;
525 jmethodID jId = 0;
526 jobject jProviderInstanceLocal = 0;
527
|
528 mark.hamzy 1.61 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jarName = "<<jarName<<", className = "<<className<<", pszProviderName = "<<pszProviderName<<", pjClass = "<<PEGASUS_STD(hex)<<(long)pjClass<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
529 mark.hamzy 1.57
530 // CASE #1
531 // className has been loaded previously.
532 // Return saved instance.
533 _objectTable.lookup (className, jProviderInstance);
534 _classTable.lookup (className, jClassLoaded);
535
|
536 mark.hamzy 1.61 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jProviderInstance = "<<PEGASUS_STD(hex)<<(long)jProviderInstance<<", jClassLoaded = "<<(long)jClassLoaded<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
537 mark.hamzy 1.57
538 if ( jProviderInstance
539 && jClassLoaded
540 )
541 {
542 if (pjClass)
543 {
544 *pjClass = jClassLoaded;
545 }
546
547 return jProviderInstance;
548 }
549
550 // CASE #2
551 // className can be loaded via getGlobalClassRef ().
552 // Load and return the instance.
553 // NOTE:
554 // According to http://java.sun.com/j2se/1.5.0/docs/guide/jni/spec/functions.html
555 // In JDK 1.1, FindClass searched only local classes in CLASSPATH.
|
556 mark.hamzy 1.16
|
557 mark.hamzy 1.57 jClassLoaded = getGlobalClassRef (env,
558 (const char*)className.getCString ());
|
559 mark.hamzy 1.17
|
560 mark.hamzy 1.61 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jClassLoaded = "<<PEGASUS_STD(hex)<<(long)jClassLoaded<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
561 mark.hamzy 1.16
|
562 mark.hamzy 1.57 if (env->ExceptionCheck ())
|
563 mark.hamzy 1.44 {
|
564 mark.hamzy 1.57 // CASE #3
565 // see if the className can be loaded via JarClassLoader.load ().
566 // Load and return the instance.
|
567 mark.hamzy 1.58 jstring jJarName = 0;
568 jstring jClassName = 0;
569 jclass jClassLoadedLocal = 0;
|
570 mark.hamzy 1.57
571 env->ExceptionClear ();
572
573 // NOTE: Instances of "packageName/className" will not work with the jar
574 // class loader. Change the '/' to a '.'.
575 String fixedClassName;
576 Uint32 idx = className.find ('/');
577
578 if (idx != PEG_NOT_FOUND)
579 {
580 fixedClassName = className.subString (0, idx)
581 + "."
582 + className.subString (idx + 1);
583 }
584 else
585 {
586 fixedClassName = className;
587 }
588
589 DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::getProvider: fixedClassName = "<<fixedClassName<<PEGASUS_STD(endl));
590
591 mark.hamzy 1.57 jJarName = env->NewStringUTF ((const char*)jarName.getCString ());
592 jClassName = env->NewStringUTF ((const char*)fixedClassName.getCString ());
593
|
594 mark.hamzy 1.61 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jJarName = "<<PEGASUS_STD(hex)<<(long)jJarName<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
595 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jClassName = "<<PEGASUS_STD(hex)<<(long)jClassName<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
596 mark.hamzy 1.57
|
597 mark.hamzy 1.59 jClassLoadedLocal = (jclass)env->CallStaticObjectMethod (JMPIjvm::jv.JarClassLoaderClassRef,
|
598 mark.hamzy 1.58 JMPIjvm::jv.JarClassLoaderLoad,
599 jJarName,
600 jClassName);
|
601 mark.hamzy 1.57
|
602 mark.hamzy 1.61 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jClassLoadedLocal = "<<PEGASUS_STD(hex)<<(long)jClassLoadedLocal<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
603 mark.hamzy 1.57
604 if (env->ExceptionCheck ())
605 {
606 DDD (env->ExceptionDescribe ());
607
608 DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<pszProviderName<<PEGASUS_STD(endl));
609
610 return 0;
611 }
|
612 mark.hamzy 1.58
613 jClassLoaded = (jclass)env->NewGlobalRef (jClassLoadedLocal);
614
|
615 mark.hamzy 1.61 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jClassLoaded = "<<PEGASUS_STD(hex)<<(long)jClassLoaded<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
616 mark.hamzy 1.58
617 env->DeleteLocalRef (jClassLoadedLocal);
|
618 schuur 1.1 }
619
|
620 mark.hamzy 1.57 if (pjClass)
|
621 mark.hamzy 1.44 {
|
622 mark.hamzy 1.57 *pjClass = jClassLoaded;
|
623 schuur 1.1 }
624
|
625 mark.hamzy 1.57 if (!jClassLoaded)
|
626 mark.hamzy 1.44 {
|
627 mark.hamzy 1.57 DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<pszProviderName<<PEGASUS_STD(endl));
|
628 mark.hamzy 1.16
|
629 mark.hamzy 1.57 return 0;
|
630 schuur 1.1 }
|
631 mark.hamzy 1.17
|
632 mark.hamzy 1.57 jId = env->GetMethodID (jClassLoaded,
633 "<init>",
634 "()V");
635
|
636 mark.hamzy 1.61 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jId = "<<PEGASUS_STD(hex)<<(long)jId<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
637 mark.hamzy 1.57
638 jProviderInstanceLocal = env->NewObject (jClassLoaded,
639 jId);
640
|
641 mark.hamzy 1.61 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jProviderInstanceLocal = "<<PEGASUS_STD(hex)<<(long)jProviderInstanceLocal<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
642 mark.hamzy 1.57
643 if (!jProviderInstanceLocal)
|
644 mark.hamzy 1.17 {
|
645 mark.hamzy 1.57 DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<pszProviderName<<PEGASUS_STD(endl));
646
647 return 0;
|
648 mark.hamzy 1.17 }
|
649 schuur 1.1
|
650 mark.hamzy 1.57 jProviderInstance = (jobject)env->NewGlobalRef (jProviderInstanceLocal);
651
|
652 mark.hamzy 1.61 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jProviderInstance = "<<PEGASUS_STD(hex)<<(long)jProviderInstance<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
653 mark.hamzy 1.57
654 if (!jProviderInstance)
|
655 mark.hamzy 1.44 {
|
656 mark.hamzy 1.57 DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<pszProviderName<<PEGASUS_STD(endl));
657
658 return 0;
|
659 schuur 1.1 }
|
660 mark.hamzy 1.17
|
661 mark.hamzy 1.57 _classTable.insert (className, jClassLoaded);
662 _objectTable.insert (className, jProviderInstance);
|
663 mark.hamzy 1.17
|
664 mark.hamzy 1.57 return jProviderInstance;
|
665 schuur 1.1 }
666
|
667 mark.hamzy 1.62 jobject JMPIjvm::getProvider (JNIEnv *env, const char *cn, jclass *cls)
|
668 schuur 1.1 {
|
669 mark.hamzy 1.17 String cln = cn;
|
670 mark.hamzy 1.44 jobject gProv = NULL;
671 jclass scls = NULL;
|
672 mark.hamzy 1.16
|
673 mark.hamzy 1.18 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: cn = "<<cn<<", cls = "<<cls<<PEGASUS_STD(endl));
|
674 mark.hamzy 1.17
675 _objectTable.lookup(cln,gProv);
676 _classTable.lookup(cln,scls);
|
677 mark.hamzy 1.61 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(long)gProv<<", scls = "<<(long)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
678 mark.hamzy 1.16
|
679 mark.hamzy 1.44 if (gProv)
680 {
681 *cls = scls;
|
682 schuur 1.1 return gProv;
683 }
684
|
685 mark.hamzy 1.44 scls = getGlobalClassRef(env,cn);
686 if (env->ExceptionCheck())
687 {
|
688 mark.hamzy 1.18 DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::getProvider: Provider "<<cn<<" not found"<<PEGASUS_STD(endl));
|
689 mark.hamzy 1.16 DDD(env->ExceptionDescribe());
690
|
691 schuur 1.1 return NULL;
692 }
|
693 mark.hamzy 1.44 *cls = scls;
|
694 mark.hamzy 1.17
695 if (scls)
696 {
|
697 mark.hamzy 1.61 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: scls = "<<PEGASUS_STD(hex)<<(long)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
698 mark.hamzy 1.17 _classTable.insert(cln,scls);
699 }
|
700 schuur 1.1
|
701 mark.hamzy 1.44 jmethodID id = env->GetMethodID(*cls,"<init>","()V");
702 jobject lProv = env->NewObject(*cls,id);
703 gProv = (jobject)env->NewGlobalRef(lProv);
704 if (env->ExceptionCheck())
705 {
|
706 mark.hamzy 1.16 DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<cn<<PEGASUS_STD(endl));
|
707 schuur 1.1 return NULL;
708 }
|
709 mark.hamzy 1.17
710 if (gProv)
711 {
|
712 mark.hamzy 1.61 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(long)gProv<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
713 mark.hamzy 1.17 _objectTable.insert(cln,gProv);
714 }
715
|
716 schuur 1.1 return gProv;
717 }
718
|
719 mark.hamzy 1.62 void JMPIjvm::checkException (JNIEnv *env)
|
720 schuur 1.1 {
|
721 mark.hamzy 1.44 if (env->ExceptionCheck ())
722 {
723 jstring jMsg = NULL,
724 jId = NULL;
725 int code;
|
726 schuur 1.7 const char *cp;
|
727 kumpf 1.69 String msg;
728 String id;
|
729 mark.hamzy 1.44 jthrowable err = env->ExceptionOccurred();
|
730 schuur 1.7
|
731 mark.hamzy 1.16 DDD(env->ExceptionDescribe());
|
732 mark.hamzy 1.44
733 if (env->IsInstanceOf (err, JMPIjvm::jv.CIMExceptionClassRef))
734 {
735 env->ExceptionClear ();
736 if (err)
737 {
738 jMsg = (jstring)env->CallObjectMethod (err, JMPIjvm::jv.ThrowableGetMessage);
739 code = (int)env->CallIntMethod (err, JMPIjvm::jv.CIMExceptionGetCode);
740 jId = (jstring)env->CallObjectMethod (err, JMPIjvm::jv.CIMExceptionGetID);
741
742 if (jId)
743 {
744 cp = env->GetStringUTFChars (jId, NULL);
745 id = String (cp);
746 env->ReleaseStringUTFChars (jId, cp);
|
747 schuur 1.7 }
748
|
749 mark.hamzy 1.44 if (jMsg)
750 {
751 cp = env->GetStringUTFChars (jMsg, NULL);
752 msg = String (cp);
753 env->ReleaseStringUTFChars (jMsg, cp);
|
754 schuur 1.7 }
|
755 mark.hamzy 1.16
756 DDD(PEGASUS_STD(cerr)<<"--- throwing Pegasus exception: "<<code<<" "<<id<<" ("<<msg<<")"<<PEGASUS_STD(endl));
757
|
758 mark.hamzy 1.44 throw CIMException ((CIMStatusCode)code, id+" ("+msg+")");
|
759 mark.hamzy 1.17 }
|
760 schuur 1.7 }
|
761 mark.hamzy 1.44 else
762 {
|
763 mark.hamzy 1.28 DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::checkException: exiting..."<<PEGASUS_STD(endl));
|
764 schuur 1.7 env->ExceptionDescribe();
765 exit(13);
|
766 schuur 1.1 }
|
767 mark.hamzy 1.28 }
|
768 schuur 1.2 }
|
769 schuur 1.1
770 /**************************************************************************
771 * name - NewPlatformString
772 * description - Returns a new Java string object for the specified
773 * platform string.
774 * parameters - env
775 * s Platform encoded string
776 * returns - Java string object pointer or null (0)
777 **************************************************************************/
|
778 mark.hamzy 1.44 jstring JMPIjvm::NewPlatformString (JNIEnv *env, char *s)
|
779 schuur 1.1 {
|
780 mark.hamzy 1.44 size_t len = strlen(s);
781 jclass cls;
782 jmethodID mid;
|
783 schuur 1.1 jbyteArray ary;
784
785 NULL_CHECK0(cls = (*env).FindClass("java/lang/String"));
786 NULL_CHECK0(mid = (*env).GetMethodID(cls, "<init>", "([B)V"));
|
787 mark.hamzy 1.44
|
788 schuur 1.1 ary = (*env).NewByteArray((jsize)len);
|
789 mark.hamzy 1.44 if (ary != 0)
790 {
|
791 schuur 1.1 jstring str = 0;
|
792 mark.hamzy 1.44 (*env).SetByteArrayRegion (ary,
793 0,
794 (jsize)len,
|
795 schuur 1.1 (jbyte *)s);
|
796 mark.hamzy 1.44 if (!(*env).ExceptionOccurred ())
797 {
798 str = (jstring)(*env).NewObject (cls, mid, ary);
|
799 schuur 1.1 }
|
800 mark.hamzy 1.44 (*env).DeleteLocalRef (ary);
801
|
802 schuur 1.1 return str;
803 }
804 return 0;
805 }
806
807 /**************************************************************************
808 * name - NewPlatformStringArray
809 * description - Returns a new array of Java string objects for the specified
810 * array of platform strings.
811 * parameters - env
812 * strv Platform encoded string array
813 * strc Number of strings in strv
814 * returns - Java string array object pointer
815 **************************************************************************/
|
816 mark.hamzy 1.62 jobjectArray JMPIjvm::NewPlatformStringArray (JNIEnv *env, char **strv, int strc)
|
817 schuur 1.1 {
818 jarray cls;
819 jarray ary;
820 int i;
821
822 NULL_CHECK0(cls = (jarray)(*env).FindClass("java/lang/String"));
823 NULL_CHECK0(ary = (*env).NewObjectArray(strc, (jclass)cls, 0));
|
824 mark.hamzy 1.44 for(i = 0; i < strc; i++)
825 {
826 jstring str = NewPlatformString (env, *strv++);
827
|
828 schuur 1.1 NULL_CHECK0(str);
|
829 mark.hamzy 1.44
830 (*env).SetObjectArrayElement ((jobjectArray)ary, i, str);
831 (*env).DeleteLocalRef (str);
|
832 schuur 1.1 }
|
833 mark.hamzy 1.44
|
834 schuur 1.1 return (jobjectArray)ary;
835 }
836
|
837 mark.hamzy 1.62 CIMPropertyList getList (JNIEnv *jEnv, jobjectArray l)
|
838 mark.hamzy 1.44 {
|
839 mark.hamzy 1.33 CIMPropertyList pl;
840
|
841 mark.hamzy 1.44 if (l)
842 {
|
843 mark.hamzy 1.33 Array<CIMName> n;
844
|
845 mark.hamzy 1.44 for (jsize i = 0, s = jEnv->GetArrayLength (l); i <s; i++)
846 {
847 jstring jObj = (jstring)jEnv->GetObjectArrayElement (l, i);
848 const char *pn = jEnv->GetStringUTFChars (jObj, NULL);
|
849 mark.hamzy 1.33
|
850 mark.hamzy 1.44 n.append (pn);
|
851 mark.hamzy 1.33
|
852 mark.hamzy 1.44 jEnv->ReleaseStringUTFChars (jObj, pn);
|
853 mark.hamzy 1.33 }
854
|
855 mark.hamzy 1.44 pl.set (n);
|
856 mark.hamzy 1.33 }
857
858 return pl;
859 }
860
|
861 schuur 1.1 extern "C" {
862
|
863 mark.hamzy 1.44 void throwCimException (JNIEnv *jEnv, CIMException &e)
864 {
|
865 schuur 1.1 JMPIjvm::cacheIDs(jEnv);
|
866 mark.hamzy 1.44 jobject ev = jEnv->NewObject(JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewI,(jint)e.getCode());
|
867 schuur 1.1 jEnv->Throw((jthrowable)ev);
868 }
869
|
870 mark.hamzy 1.44 void throwFailedException (JNIEnv *jEnv)
871 {
|
872 schuur 1.1 JMPIjvm::cacheIDs(jEnv);
|
873 mark.hamzy 1.44 jobject ev = jEnv->NewObject(JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewI,1);
|
874 schuur 1.1 jEnv->Throw((jthrowable)ev);
875 }
876
|
877 mark.hamzy 1.44 void throwNotSupportedException (JNIEnv *jEnv)
878 {
|
879 schuur 1.1 JMPIjvm::cacheIDs(jEnv);
|
880 mark.hamzy 1.44 jobject ev = jEnv->NewObject(JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewI,7);
|
881 schuur 1.1 jEnv->Throw((jthrowable)ev);
882 }
883
884
|
885 schuur 1.7 // -------------------------------------
886 // ---
|
887 mark.hamzy 1.62 // - CIMArgument
|
888 schuur 1.7 // ---
889 // -------------------------------------
890
|
891 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1new
892 (JNIEnv *jEnv, jobject jThs)
|
893 mark.hamzy 1.44 {
|
894 mark.hamzy 1.62 CIMParamValue *p = new CIMParamValue (String::EMPTY,CIMValue ());
|
895 mark.hamzy 1.56
|
896 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMParamValue*, jlong, p);
|
897 schuur 1.7 }
898
|
899 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1newS
900 (JNIEnv *jEnv, jobject jThs, jstring jN)
|
901 mark.hamzy 1.44 {
|
902 mark.hamzy 1.62 const char *str = jEnv->GetStringUTFChars (jN, NULL);
903 CIMParamValue *p = new CIMParamValue (str, CIMValue ());
904
905 jEnv->ReleaseStringUTFChars (jN, str);
|
906 mark.hamzy 1.56
|
907 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMParamValue*, jlong, p);
|
908 schuur 1.7 }
909
|
910 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1newSV
911 (JNIEnv *jEnv, jobject jThs, jstring jN, jlong jV)
|
912 mark.hamzy 1.44 {
|
913 mark.hamzy 1.62 const char *str = jEnv->GetStringUTFChars (jN, NULL);
914 CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);
915 CIMParamValue *p = 0;
|
916 mark.hamzy 1.56
|
917 mark.hamzy 1.62 if ( str
918 && cv
919 )
920 {
921 p = new CIMParamValue (str, *cv);
922 }
|
923 schuur 1.7
|
924 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jN, str);
|
925 mark.hamzy 1.56
|
926 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMParamValue*, jlong, p);
|
927 schuur 1.7 }
928
|
929 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1getType
930 (JNIEnv *jEnv, jobject jThs, jlong jP)
|
931 mark.hamzy 1.44 {
|
932 mark.hamzy 1.62 CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);
933 const CIMValue cv = cp->getValue ();
934 String ref;
935 bool fSuccess = false;
936 int iJType = 0;
937 _dataType *type = 0;
|
938 mark.hamzy 1.56
|
939 mark.hamzy 1.62 iJType = _dataType::convertCTypeToJavaType (cv.getType (), &fSuccess);
|
940 schuur 1.7
|
941 mark.hamzy 1.62 if (fSuccess)
942 {
943 type = new _dataType (iJType,
944 cv.getArraySize (),
945 false,
946 false,
947 cv.isArray (),
948 ref,
949 true);
950 }
|
951 schuur 1.7
|
952 mark.hamzy 1.62 return DEBUG_ConvertCToJava (_dataType*, jlong, type);
953 }
|
954 schuur 1.7
|
955 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setValue
956 (JNIEnv *jEnv, jobject jThs, jlong jP,jlong jV)
|
957 mark.hamzy 1.20 {
|
958 mark.hamzy 1.62 CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);
959 CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);
|
960 mark.hamzy 1.20
|
961 mark.hamzy 1.62 cp->setValue (*cv);
962 }
|
963 mark.hamzy 1.20
|
964 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1getValue
965 (JNIEnv *jEnv, jobject jThs, jlong jP)
966 {
967 CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);
968 CIMValue *cv = new CIMValue (cp->getValue ());
|
969 mark.hamzy 1.20
|
970 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
|
971 schuur 1.1 }
972
|
973 mark.hamzy 1.62 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMArgument__1getName
974 (JNIEnv *jEnv, jobject jThs, jlong jP)
|
975 mark.hamzy 1.20 {
|
976 mark.hamzy 1.62 CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);
977 const String &n = cp->getParameterName ();
978 jstring str = jEnv->NewStringUTF (n.getCString ());
|
979 mark.hamzy 1.20
|
980 mark.hamzy 1.62 return str;
|
981 schuur 1.7 }
982
|
983 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setName
984 (JNIEnv *jEnv, jobject jThs, jlong jP, jstring jN)
|
985 mark.hamzy 1.20 {
|
986 mark.hamzy 1.62 CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);
987 const char *str = jEnv->GetStringUTFChars (jN, NULL);
988 String n (str);
989
990 cp->setParameterName (n);
|
991 mark.hamzy 1.20
|
992 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jN, str);
|
993 schuur 1.7 }
994
|
995 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1finalize
996 (JNIEnv *jEnv, jobject jThs, jlong jP)
|
997 mark.hamzy 1.20 {
|
998 mark.hamzy 1.62 CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);
999
1000 delete cp;
|
1001 schuur 1.7
|
1002 mark.hamzy 1.62 DEBUG_ConvertCleanup (jlong, jP);
|
1003 schuur 1.7 }
1004
|
1005 mark.hamzy 1.62
1006 // -------------------------------------
1007 // ---
1008 // - CIMClass
1009 // ---
1010 // -------------------------------------
1011
1012 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1newInstance
1013 (JNIEnv *jEnv, jobject jThs, jlong jCls)
|
1014 mark.hamzy 1.20 {
|
1015 mark.hamzy 1.62 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
|
1016 mark.hamzy 1.20
|
1017 mark.hamzy 1.62 if (cls)
1018 {
1019 try
|
1020 mark.hamzy 1.44 {
|
1021 mark.hamzy 1.62 CIMInstance *ci = new CIMInstance (cls->getClassName ());
1022 CIMObjectPath copNew = ci->getPath ();
|
1023 mark.hamzy 1.20
|
1024 mark.hamzy 1.62 copNew.setNameSpace (cls->getPath ().getNameSpace ());
1025 ci->setPath (copNew);
|
1026 mark.hamzy 1.20
|
1027 mark.hamzy 1.62 for (int i = 0, m = cls->getQualifierCount (); i < m; i++)
1028 {
1029 try
1030 {
1031 ci->addQualifier (cls->getQualifier (i).clone ());
1032 }
1033 catch (Exception e)
1034 {
1035 }
1036 }
1037 for (int i = 0, m = cls->getPropertyCount (); i < m; i++)
1038 {
1039 CIMProperty cp = cls->getProperty (i);
|
1040 schuur 1.7
|
1041 mark.hamzy 1.62 ci->addProperty (cp.clone ());
|
1042 mark.hamzy 1.20
|
1043 mark.hamzy 1.62 for (int j = 0, s = cp.getQualifierCount (); j < s; j++)
1044 {
1045 try
1046 {
1047 ci->getProperty (i).addQualifier (cp.getQualifier (j));
1048 }
1049 catch (Exception e)
1050 {
1051 }
1052 }
1053 }
|
1054 mark.hamzy 1.20
|
1055 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMInstance*, jlong, ci);
1056 }
1057 Catch (jEnv);
|
1058 schuur 1.7 }
|
1059 mark.hamzy 1.20
|
1060 schuur 1.7 return 0;
1061 }
1062
|
1063 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1filterProperties
1064 (JNIEnv *jEnv, jobject jThs, jlong jInst, jobjectArray jPl, jboolean iq, jboolean ic, jboolean lo)
|
1065 mark.hamzy 1.20 {
|
1066 mark.hamzy 1.62 CIMClass *cc = DEBUG_ConvertJavaToC (jlong, CIMClass*, jInst);
1067 CIMClass *cf = 0;
1068 CIMName clsn = cc->getClassName ();
1069
1070 if (lo)
1071 {
1072 cf = new CIMClass (cc->clone ());
|
1073 mark.hamzy 1.20
|
1074 mark.hamzy 1.62 CIMName clsn = cc->getClassName ();
|
1075 schuur 1.7
|
1076 mark.hamzy 1.62 for (int i = cf->getPropertyCount () - 1; i>= 0; i--)
1077 {
1078 if (cf->getProperty (i).getClassOrigin () == clsn)
1079 cf->removeProperty (i);
1080 }
|
1081 mark.hamzy 1.44
|
1082 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMClass*, jlong, cf);
|
1083 schuur 1.7 }
|
1084 mark.hamzy 1.62 else if (jPl)
1085 {
1086 CIMPropertyList pl = getList (jEnv,jPl);
1087 Array<CIMName> n = pl.getPropertyNameArray ();
1088
1089 cf = new CIMClass (clsn, cc->getSuperClassName ());
|
1090 mark.hamzy 1.20
|
1091 mark.hamzy 1.62 for (int i = 0, s = n.size (); i < s; i++)
1092 {
1093 Uint32 pos = cc->findProperty (n[i]);
|
1094 schuur 1.7
|
1095 mark.hamzy 1.62 if (pos != PEG_NOT_FOUND)
1096 {
1097 if (iq)
1098 {
1099 CIMProperty cp = cc->getProperty (pos).clone ();
|
1100 schuur 1.7
|
1101 mark.hamzy 1.62 if (!ic)
1102 cp.setClassOrigin (CIMName ());
|
1103 schuur 1.7
|
1104 mark.hamzy 1.62 cf->addProperty (cp);
1105 }
1106 else
1107 {
1108 CIMProperty cp = cc->getProperty (pos);
1109 CIMName co;
|
1110 mark.hamzy 1.20
|
1111 mark.hamzy 1.62 if (ic)
1112 co = cp.getClassOrigin ();
|
1113 mark.hamzy 1.20
|
1114 mark.hamzy 1.62 CIMProperty np (cp.getName (),
1115 cp.getValue (),
1116 cp.getArraySize (),
1117 cp.getReferenceClassName (),
1118 co,
1119 cp.getPropagated ());
|
1120 mark.hamzy 1.20
|
1121 mark.hamzy 1.62 cf->addProperty (np);
1122 }
1123 }
1124 }
1125 if (iq)
1126 {
1127 for (Uint32 i = 0, s = cc->getQualifierCount (); i < s; i++)
1128 {
1129 cf->addQualifier (cc->getQualifier (i));
1130 }
1131 }
|
1132 schuur 1.7 }
|
1133 mark.hamzy 1.62 else if (iq)
1134 {
1135 cf = new CIMClass (cc->clone ());
|
1136 mark.hamzy 1.20
|
1137 mark.hamzy 1.62 if (ic)
1138 return DEBUG_ConvertCToJava (CIMClass*, jlong, cf);
|
1139 schuur 1.7
|
1140 mark.hamzy 1.62 for (int i = cf->getPropertyCount () - 1; i >= 0; i--)
1141 {
1142 CIMProperty cp = cf->getProperty (i);
|
1143 mark.hamzy 1.20
|
1144 mark.hamzy 1.62 cp.setClassOrigin (CIMName ());
1145 cf->removeProperty (i);
1146 cf->addProperty (cp);
1147 }
|
1148 schuur 1.7 }
|
1149 mark.hamzy 1.62 else
1150 {
1151 cf = new CIMClass (clsn, cc->getSuperClassName ());
1152
1153 for (int i = cc->getPropertyCount () - 1; i >= 0; i--)
1154 {
1155 CIMProperty cp = cc->getProperty (i);
1156 CIMName co;
1157
1158 if (ic)
1159 co = cp.getClassOrigin ();
|
1160 schuur 1.7
|
1161 mark.hamzy 1.62 CIMProperty np (cp.getName (),
1162 cp.getValue (),
1163 cp.getArraySize (),
1164 cp.getReferenceClassName (),
1165 co,
1166 cp.getPropagated ());
|
1167 mark.hamzy 1.20
|
1168 mark.hamzy 1.62 cf->addProperty (np);
1169 }
|
1170 schuur 1.7 }
|
1171 mark.hamzy 1.20
|
1172 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMClass*, jlong, cf);
|
1173 schuur 1.7 }
1174
|
1175 mark.hamzy 1.62 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getName
1176 (JNIEnv *jEnv, jobject jThs, jlong jCls)
|
1177 mark.hamzy 1.20 {
|
1178 mark.hamzy 1.62 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
|
1179 mark.hamzy 1.20
|
1180 schuur 1.7 try {
|
1181 mark.hamzy 1.62 const String &cn = cls->getClassName ().getString ();
1182 jstring str = jEnv->NewStringUTF (cn.getCString ());
|
1183 mark.hamzy 1.44
|
1184 mark.hamzy 1.62 return str;
|
1185 schuur 1.7 }
|
1186 mark.hamzy 1.44 Catch (jEnv);
|
1187 mark.hamzy 1.20
|
1188 schuur 1.7 return 0;
1189 }
1190
|
1191 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifier
1192 (JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jN)
|
1193 mark.hamzy 1.20 {
|
1194 mark.hamzy 1.62 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
1195 const char *str = jEnv->GetStringUTFChars (jN, NULL);
1196 jlong rv = 0;
1197 Uint32 pos = cls->findQualifier (String (str));
|
1198 schuur 1.7
|
1199 mark.hamzy 1.62 if (pos != PEG_NOT_FOUND)
1200 rv = DEBUG_ConvertCToJava (CIMQualifier*,
1201 jlong,
1202 new CIMQualifier (cls->getQualifier (pos)));
|
1203 mark.hamzy 1.27
|
1204 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jN, str);
|
1205 mark.hamzy 1.20
|
1206 mark.hamzy 1.62 return rv;
1207 }
|
1208 mark.hamzy 1.20
|
1209 mark.hamzy 1.62 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifiers
1210 (JNIEnv *jEnv, jobject jThs, jlong jCls, jobject jVec)
1211 {
1212 JMPIjvm::cacheIDs (jEnv);
|
1213 schuur 1.7
|
1214 mark.hamzy 1.62 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
|
1215 mark.hamzy 1.20
|
1216 mark.hamzy 1.62 for (int i = 0, s = cls->getQualifierCount (); i < s; i++)
1217 {
1218 CIMQualifier *cq = new CIMQualifier (cls->getQualifier (i));
1219 jlong jCq = DEBUG_ConvertCToJava (CIMQualifier*, jlong, cq);
1220 jobject qual = jEnv->NewObject (JMPIjvm::jv.CIMQualifierClassRef,JMPIjvm::jv.CIMQualifierNewJ,jCq);
|
1221 mark.hamzy 1.20
|
1222 mark.hamzy 1.62 jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,qual);
|
1223 schuur 1.1 }
|
1224 mark.hamzy 1.20
|
1225 mark.hamzy 1.62 return jVec;
|
1226 schuur 1.1 }
1227
|
1228 mark.hamzy 1.62 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1hasQualifier
1229 (JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jQ)
1230 {
1231 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
1232 const char *str = jEnv->GetStringUTFChars (jQ,NULL);
1233 Uint32 pos = cls->findQualifier (String (str));
|
1234 schuur 1.7
|
1235 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jQ,str);
|
1236 mark.hamzy 1.27
|
1237 mark.hamzy 1.62 return (jboolean)(pos != PEG_NOT_FOUND);
1238 }
|
1239 schuur 1.3
|
1240 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1addProperty
1241 (JNIEnv *jEnv, jobject jThs, jlong jCls, jlong jP)
1242 {
1243 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
1244 CIMProperty *p = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);
|
1245 mark.hamzy 1.20
|
1246 mark.hamzy 1.62 try
1247 {
1248 cls->addProperty (*p);
|
1249 schuur 1.1 }
|
1250 mark.hamzy 1.44 Catch (jEnv);
|
1251 mark.hamzy 1.62 }
|
1252 mark.hamzy 1.20
|
1253 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1setProperties
1254 (JNIEnv *jEnv, jobject jThs, jlong jCls, jobject jVec)
|
1255 mark.hamzy 1.20 {
|
1256 mark.hamzy 1.62 JMPIjvm::cacheIDs (jEnv);
|
1257 mark.hamzy 1.20
|
1258 mark.hamzy 1.62 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
|
1259 mark.hamzy 1.27
|
1260 mark.hamzy 1.62 for (int i = cls->getPropertyCount () - 1; i >= 0; i--)
1261 {
1262 cls->removeProperty (i);
|
1263 schuur 1.7 }
|
1264 mark.hamzy 1.62 for (Uint32 i = 0, s = jEnv->CallIntMethod (jVec, JMPIjvm::jv.VectorSize); i < s; i++)
1265 {
1266 JMPIjvm::checkException (jEnv);
|
1267 schuur 1.7
|
1268 mark.hamzy 1.62 jobject o = jEnv->CallObjectMethod (jVec,JMPIjvm::jv.VectorElementAt, (i));
1269 jlong jp = jEnv->CallLongMethod (o,JMPIjvm::jv.CIMPropertyCInst);
1270 CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jp);
|
1271 mark.hamzy 1.30
|
1272 mark.hamzy 1.62 JMPIjvm::checkException (jEnv);
|
1273 schuur 1.7
|
1274 mark.hamzy 1.62 cls->addProperty (*cp);
1275 }
1276 }
|
1277 schuur 1.7
|
1278 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperty
1279 (JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jN)
1280 {
1281 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
1282 const char *str = jEnv->GetStringUTFChars (jN,NULL);
1283 jlong rv = 0;
1284 Uint32 pos = cls->findProperty (CIMName (str));
|
1285 schuur 1.7
|
1286 mark.hamzy 1.62 if (pos != PEG_NOT_FOUND)
1287 rv = DEBUG_ConvertCToJava (CIMProperty*,
1288 jlong,
1289 new CIMProperty (cls->getProperty (pos)));
|
1290 mark.hamzy 1.20
|
1291 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jN,str);
|
1292 mark.hamzy 1.23
|
1293 mark.hamzy 1.62 return rv;
1294 }
|
1295 mark.hamzy 1.20
|
1296 mark.hamzy 1.62 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties
1297 (JNIEnv *jEnv, jobject jThs, jlong jCls, jobject jVec)
1298 {
1299 JMPIjvm::cacheIDs (jEnv);
|
1300 mark.hamzy 1.20
|
1301 mark.hamzy 1.62 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
|
1302 mark.hamzy 1.20
|
1303 mark.hamzy 1.62 for (int i = 0, s = cls->getPropertyCount (); i < s; i++)
1304 {
1305 CIMProperty *cp = new CIMProperty (cls->getProperty (i));
1306 jlong jCp = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp);
1307 jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewJ,jCp);
|
1308 schuur 1.7
|
1309 mark.hamzy 1.62 jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,prop);
|
1310 mark.hamzy 1.20 }
1311
|
1312 mark.hamzy 1.62 return jVec;
|
1313 schuur 1.7 }
|
1314 schuur 1.1
|
1315 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1new
1316 (JNIEnv *jEnv, jobject jThs, jstring jN)
|
1317 mark.hamzy 1.20 {
|
1318 mark.hamzy 1.62 const char *str = jEnv->GetStringUTFChars (jN,NULL);
1319 CIMClass *cls = new CIMClass (CIMName (str), CIMName ());
|
1320 mark.hamzy 1.30
|
1321 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jN,str);
|
1322 mark.hamzy 1.20
|
1323 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMClass*, jlong, cls);
1324 }
|
1325 schuur 1.7
|
1326 mark.hamzy 1.62 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getSuperClass
1327 (JNIEnv *jEnv, jobject jThs, jlong jCls)
1328 {
1329 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
1330 const String &cn = cls->getSuperClassName ().getString ();
|
1331 schuur 1.3
|
1332 mark.hamzy 1.62 jstring str = jEnv->NewStringUTF (cn.getCString ());
|
1333 mark.hamzy 1.44
|
1334 mark.hamzy 1.62 return str;
1335 }
|
1336 mark.hamzy 1.20
|
1337 mark.hamzy 1.62 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getKeys
1338 (JNIEnv *jEnv, jobject jThs, jlong jCls, jobject jVec)
1339 {
1340 JMPIjvm::cacheIDs (jEnv);
|
1341 mark.hamzy 1.20
|
1342 mark.hamzy 1.62 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
|
1343 mark.hamzy 1.20
|
1344 mark.hamzy 1.62 if (cls->hasKeys ())
1345 {
1346 Array<CIMName> keyNames;
|
1347 mark.hamzy 1.20
|
1348 mark.hamzy 1.62 cls->getKeyNames (keyNames);
|
1349 schuur 1.7
|
1350 mark.hamzy 1.62 for (int i = 0, s = keyNames.size (); i < s; i++)
|
1351 mark.hamzy 1.43 {
|
1352 mark.hamzy 1.62 Uint32 pos = cls->findProperty (keyNames[i]);
1353
1354 if (pos != PEG_NOT_FOUND)
|
1355 mark.hamzy 1.44 {
|
1356 mark.hamzy 1.62 CIMProperty *cp = new CIMProperty (cls->getProperty (pos));
1357 jlong jCp = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp);
1358
1359 jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewJ,jCp);
|
1360 mark.hamzy 1.20
|
1361 mark.hamzy 1.62 jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,prop);
|
1362 mark.hamzy 1.43 }
|
1363 schuur 1.7 }
|
1364 schuur 1.1 }
|
1365 mark.hamzy 1.20
|
1366 mark.hamzy 1.62 return jVec;
|
1367 schuur 1.1 }
1368
|
1369 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethod
1370 (JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jN)
|
1371 mark.hamzy 1.20 {
|
1372 mark.hamzy 1.62 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
1373 const char *str = jEnv->GetStringUTFChars (jN,NULL);
1374 jlong rv = 0;
1375 Uint32 pos = cls->findMethod (String (str));
|
1376 mark.hamzy 1.23
|
1377 mark.hamzy 1.62 if (pos != PEG_NOT_FOUND)
|
1378 mark.hamzy 1.44 {
|
1379 mark.hamzy 1.62 rv = DEBUG_ConvertCToJava (CIMMethod*, jlong, new CIMMethod (cls->getMethod (pos)));
|
1380 mark.hamzy 1.44 }
|
1381 mark.hamzy 1.23
|
1382 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jN,str);
|
1383 mark.hamzy 1.23
|
1384 mark.hamzy 1.62 return rv;
1385 }
|
1386 mark.hamzy 1.23
|
1387 mark.hamzy 1.62 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1equals
1388 (JNIEnv *jEnv, jobject jThs, jlong jCls, jlong jClsToBeCompared)
1389 {
1390 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
1391 CIMClass *clsToBeCompared = DEBUG_ConvertJavaToC (jlong, CIMClass*, jClsToBeCompared);
1392 bool fRc = false;
|
1393 mark.hamzy 1.23
|
1394 mark.hamzy 1.62 if ( cls
1395 && clsToBeCompared
|
1396 mark.hamzy 1.44 )
1397 {
|
1398 mark.hamzy 1.62 try
|
1399 mark.hamzy 1.44 {
|
1400 mark.hamzy 1.62 fRc = cls->identical (*clsToBeCompared);
|
1401 mark.hamzy 1.44 }
|
1402 mark.hamzy 1.62 Catch (jEnv);
|
1403 mark.hamzy 1.44 }
1404
|
1405 mark.hamzy 1.62 return fRc;
1406 }
|
1407 mark.hamzy 1.44
|
1408 mark.hamzy 1.67 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1isAssociation
1409 (JNIEnv *jEnv, jobject jThs, jlong jCls)
1410 {
1411 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
1412 jboolean rv = false;
1413
1414 if (cls)
1415 {
1416 try
1417 {
1418 rv = cls->isAssociation ();
1419 }
1420 Catch (jEnv);
1421 }
1422
1423 return rv;
1424 }
1425
1426 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1findMethod
1427 (JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jName)
1428 {
1429 mark.hamzy 1.67 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
1430 jint rv = -1;
1431
1432 if (cls)
1433 {
1434 const char *cstrName = jEnv->GetStringUTFChars (jName, NULL);
1435
1436 try
1437 {
1438 CIMName name (cstrName);
1439
1440 rv = cls->findMethod (name);
1441 }
1442 Catch (jEnv);
1443
1444 jEnv->ReleaseStringUTFChars (jName, cstrName);
1445 }
1446
1447 return rv;
1448 }
1449
1450 mark.hamzy 1.67 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethodI
1451 (JNIEnv *jEnv, jobject jThs, jlong jCls, jint jMethod)
1452 {
1453 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
1454 jlong rv = 0;
1455
1456 if (cls && jMethod >=0)
1457 {
1458 try
1459 {
1460 CIMMethod cm = cls->getMethod (jMethod);
1461
1462 rv = DEBUG_ConvertCToJava (CIMMethod *, jlong, new CIMMethod (cm));
1463 }
1464 Catch (jEnv);
1465 }
1466
1467 return rv;
1468 }
1469
1470 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethodCount
1471 mark.hamzy 1.67 (JNIEnv *jEnv, jobject jThs, jlong jCls)
1472 {
1473 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
1474 jint rv = 0;
1475
1476 if (cls)
1477 {
1478 try
1479 {
1480 rv = cls->getMethodCount ();
1481 }
1482 Catch (jEnv);
1483 }
1484
1485 return rv;
1486 }
1487
|
1488 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1finalize
1489 (JNIEnv *jEnv, jobject jThs, jlong jCls)
1490 {
1491 CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
|
1492 mark.hamzy 1.44
|
1493 mark.hamzy 1.62 delete cls;
|
1494 mark.hamzy 1.44
|
1495 mark.hamzy 1.62 DEBUG_ConvertCleanup (jlong, jCls);
1496 }
|
1497 mark.hamzy 1.44
1498
|
1499 mark.hamzy 1.62 // -------------------------------------
1500 // ---
1501 // - CIMClient
1502 // ---
1503 // -------------------------------------
|
1504 mark.hamzy 1.44
|
1505 mark.hamzy 1.62 void checkNs (CIMObjectPath *cop, jlong jNs)
1506 {
1507 if (cop->getNameSpace ().isNull ())
1508 {
1509 _nameSpace *cNs = DEBUG_ConvertJavaToC (jlong, _nameSpace*, jNs);
|
1510 schuur 1.7
|
1511 mark.hamzy 1.62 cop->setNameSpace (CIMNamespaceName (cNs->nameSpace ()));
|
1512 schuur 1.7 }
1513 }
1514
|
1515 mark.hamzy 1.62 static int normalizeNs (String &ns, String &nsBase, String &lastNsComp)
|
1516 mark.hamzy 1.20 {
|
1517 mark.hamzy 1.62 Uint32 n = ns.size ();
|
1518 mark.hamzy 1.23
|
1519 mark.hamzy 1.62 if (ns[n-1] == '/')
|
1520 mark.hamzy 1.44 {
|
1521 mark.hamzy 1.62 if (n >= 2)
1522 ns = ns.subString (0, n-2);
1523 }
1524
1525 lastNsComp = ns;
1526 nsBase = "root";
|
1527 mark.hamzy 1.44
|
1528 mark.hamzy 1.62 n = ns.reverseFind ('/');
|
1529 mark.hamzy 1.44
|
1530 mark.hamzy 1.62 if (n != PEG_NOT_FOUND)
1531 {
1532 lastNsComp = ns.subString (n+1);
1533 nsBase = ns.subString (0, n);
|
1534 mark.hamzy 1.44 }
1535
|
1536 mark.hamzy 1.62 return 0;
1537 }
|
1538 mark.hamzy 1.44
|
1539 mark.hamzy 1.66 Boolean verifyServerCertificate (SSLCertificateInfo &certInfo)
1540 {
1541 //
1542 // If server certificate was found in CA trust store and validated, then
1543 // return 'true' to accept the certificate, otherwise return 'false'.
1544 //
1545 if (certInfo.getResponseCode () == 1)
1546 {
1547 return true;
1548 }
1549 else
1550 {
1551 return false;
1552 }
1553 }
1554
|
1555 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1newNaUnPw
1556 (JNIEnv *jEnv, jobject jThs, jlong jNs, jstring jUn, jstring jPw)
1557 {
1558 _nameSpace *cNs = DEBUG_ConvertJavaToC (jlong, _nameSpace*, jNs);
1559 const char *un = jEnv->GetStringUTFChars (jUn, NULL);
1560 const char *pw = jEnv->GetStringUTFChars (jPw, NULL);
1561 jlong jCc = 0;
|
1562 mark.hamzy 1.44
|
1563 mark.hamzy 1.66 SSLContext *sslContext = 0; // initialized for unencrypted connection
1564
1565 if (cNs->isHttps ())
1566 {
1567 try
1568 {
1569 sslContext = new SSLContext (PEGASUS_SSLCLIENT_CERTIFICATEFILE,
1570 verifyServerCertificate,
1571 PEGASUS_SSLCLIENT_RANDOMFILE);
1572 }
1573 catch (Exception &e)
1574 {
1575 cerr << "JMPI: Error: could not create SSLContext: " << e.getMessage() << endl;
1576 return jCc;
1577 }
1578 }
1579
|
1580 mark.hamzy 1.62 try {
1581 CIMClient *cc = new CIMClient ();
|
1582 mark.hamzy 1.44
|
1583 mark.hamzy 1.66 if (sslContext)
1584 {
1585 cc->connect (cNs->hostName (), cNs->port (), *sslContext, un, pw);
1586 }
1587 else
1588 {
1589 cc->connect (cNs->hostName (), cNs->port (), un, pw);
1590 }
|
1591 mark.hamzy 1.23
|
1592 mark.hamzy 1.62 jCc = DEBUG_ConvertCToJava (CIMClient*, jlong, cc);
|
1593 mark.hamzy 1.44 }
|
1594 mark.hamzy 1.62 Catch (jEnv);
|
1595 mark.hamzy 1.23
|
1596 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jUn, un);
1597 jEnv->ReleaseStringUTFChars (jPw, pw);
|
1598 mark.hamzy 1.23
|
1599 mark.hamzy 1.66 delete sslContext;
1600
|
1601 mark.hamzy 1.62 return jCc;
1602 }
|
1603 mark.hamzy 1.23
|
1604 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1disconnect
1605 (JNIEnv *jEnv, jobject jThs, jlong jCc)
1606 {
1607 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
|
1608 mark.hamzy 1.23
|
1609 mark.hamzy 1.62 try {
1610 cCc->disconnect ();
1611 }
1612 Catch (jEnv);
1613 }
|
1614 mark.hamzy 1.23
|
1615 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1getClass
1616 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jboolean lo,
1617 jboolean iq, jboolean ic, jobjectArray jPl)
1618 {
1619 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1620 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
1621 CIMPropertyList pl = getList (jEnv, jPl);
|
1622 mark.hamzy 1.23
|
1623 mark.hamzy 1.62 if ( cCc
1624 && cop
1625 )
1626 {
1627 try {
1628 checkNs (cop, jNs);
|
1629 mark.hamzy 1.23
|
1630 mark.hamzy 1.62 CIMClass cls = cCc->getClass (cop->getNameSpace (),
1631 cop->getClassName (),
1632 (Boolean)lo,
1633 (Boolean)iq,
1634 (Boolean)ic,
1635 pl);
1636 CIMObjectPath copNew = cls.getPath ();
|
1637 schuur 1.7
|
1638 mark.hamzy 1.62 copNew.setNameSpace (cop->getNameSpace ());
1639 cls.setPath (copNew);
|
1640 mark.hamzy 1.23
|
1641 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMClass*, jlong, new CIMClass (cls));
|
1642 schuur 1.1 }
|
1643 mark.hamzy 1.62 Catch (jEnv);
|
1644 schuur 1.1 }
|
1645 mark.hamzy 1.20
|
1646 schuur 1.7 return 0;
|
1647 schuur 1.1 }
1648
|
1649 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteClass
1650 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop)
|
1651 mark.hamzy 1.20 {
|
1652 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1653 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
|
1654 mark.hamzy 1.23
|
1655 mark.hamzy 1.62 try {
1656 checkNs (cop, jNs);
|
1657 mark.hamzy 1.23
|
1658 mark.hamzy 1.62 cCc->deleteClass (cop->getNameSpace (),
1659 cop->getClassName ());
|
1660 mark.hamzy 1.44 }
|
1661 mark.hamzy 1.62 Catch (jEnv);
1662 }
|
1663 mark.hamzy 1.23
|
1664 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createClass
1665 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jlong jCl)
1666 {
1667 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1668 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
1669 CIMClass *cl = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCl);
|
1670 mark.hamzy 1.44
|
1671 mark.hamzy 1.62 try {
1672 cCc->createClass (cop->getNameSpace (), *cl);
1673 }
1674 Catch (jEnv);
1675 }
|
1676 mark.hamzy 1.44
|
1677 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setClass
1678 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jlong jCl)
1679 {
1680 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1681 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
1682 CIMClass *cl = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCl);
|
1683 schuur 1.7
1684 try {
|
1685 mark.hamzy 1.62 checkNs (cop, jNs);
|
1686 mark.hamzy 1.23
|
1687 mark.hamzy 1.62 cCc->modifyClass (cop->getNameSpace (), *cl);
|
1688 schuur 1.7 }
|
1689 mark.hamzy 1.44 Catch (jEnv);
|
1690 schuur 1.7 }
|
1691 schuur 1.1
|
1692 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1getInstance
1693 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jboolean lo,
1694 jboolean iq, jboolean ic, jobjectArray jPl)
|
1695 mark.hamzy 1.20 {
|
1696 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
|
1697 mark.hamzy 1.61 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
|
1698 mark.hamzy 1.44 CIMPropertyList pl = getList (jEnv, jPl);
1699
|
1700 mark.hamzy 1.62 try {
1701 checkNs (cop, jNs);
1702
1703 CIMInstance inst = cCc->getInstance (cop->getNameSpace (),
1704 *cop,
1705 (Boolean)lo,
1706 (Boolean)iq,
1707 (Boolean)ic,
1708 pl);
|
1709 schuur 1.3
|
1710 mark.hamzy 1.62 inst.setPath (*cop);
|
1711 mark.hamzy 1.23
|
1712 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMInstance*, jlong, new CIMInstance (inst));
|
1713 mark.hamzy 1.44 }
|
1714 mark.hamzy 1.62 Catch (jEnv);
|
1715 mark.hamzy 1.20
|
1716 mark.hamzy 1.62 return 0;
1717 }
1718
1719 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteInstance
1720 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop)
1721 {
1722 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1723 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
|
1724 mark.hamzy 1.20
|
1725 mark.hamzy 1.62 try {
1726 checkNs (cop, jNs);
|
1727 mark.hamzy 1.44
|
1728 mark.hamzy 1.62 cCc->deleteInstance (cop->getNameSpace (), *cop);
1729 }
1730 Catch (jEnv);
1731 }
|
1732 mark.hamzy 1.44
|
1733 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1createInstance
1734 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jlong jCi)
1735 {
1736 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1737 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
1738 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jCi);
|
1739 schuur 1.7
|
1740 schuur 1.1 try {
|
1741 mark.hamzy 1.62 checkNs (cop, jNs);
1742
1743 ci->setPath (*cop);
|
1744 mark.hamzy 1.23
|
1745 mark.hamzy 1.62 CIMObjectPath obj = cCc->createInstance (cop->getNameSpace (), *ci);
|
1746 mark.hamzy 1.23
|
1747 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, new CIMObjectPath (obj));
|
1748 schuur 1.1 }
|
1749 mark.hamzy 1.44 Catch (jEnv);
|
1750 mark.hamzy 1.20
|
1751 schuur 1.7 return 0;
|
1752 schuur 1.1 }
1753
|
1754 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1modifyInstance
1755 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jlong jCi,
1756 jboolean iq, jobjectArray jPl)
|
1757 mark.hamzy 1.20 {
|
1758 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1759 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
1760 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jCi);
1761 CIMPropertyList pl = getList (jEnv, jPl);
1762
1763 try {
1764 checkNs (cop, jNs);
|
1765 schuur 1.1
|
1766 mark.hamzy 1.62 ci->setPath (*cop);
|
1767 mark.hamzy 1.37
|
1768 mark.hamzy 1.62 cCc->modifyInstance (cop->getNameSpace (), *ci, (Boolean)iq, pl);
1769 }
1770 Catch (jEnv);
1771 }
|
1772 mark.hamzy 1.37
|
1773 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClasses
1774 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jboolean deep, jboolean lo, jboolean iq, jboolean ic)
1775 {
1776 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1777 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
|
1778 mark.hamzy 1.37
|
1779 mark.hamzy 1.62 try {
1780 checkNs (cop, jNs);
|
1781 mark.hamzy 1.27
|
1782 mark.hamzy 1.62 Array<CIMClass> enm = cCc->enumerateClasses (cop->getNameSpace (),
1783 cop->getClassName (),
1784 (Boolean)deep,
1785 (Boolean)lo,
1786 (Boolean)iq,
1787 (Boolean)ic);
|
1788 mark.hamzy 1.20
|
1789 mark.hamzy 1.62 return DEBUG_ConvertCToJava (Array<CIMClass>*, jlong, new Array<CIMClass> (enm));
1790 }
1791 Catch (jEnv);
|
1792 mark.hamzy 1.20
|
1793 mark.hamzy 1.62 return 0;
1794 }
|
1795 schuur 1.3
|
1796 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClassNames
1797 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jboolean deep)
1798 {
1799 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1800 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
1801 CIMNamespaceName ns = cop->getNameSpace ();
|
1802 mark.hamzy 1.20
|
1803 mark.hamzy 1.62 try {
1804 checkNs (cop, jNs);
|
1805 schuur 1.8
|
1806 mark.hamzy 1.62 Array<CIMName> enm = cCc->enumerateClassNames (ns,
1807 cop->getClassName (),
1808 (Boolean)deep);
1809 Array<CIMObjectPath> *enmop = new Array<CIMObjectPath> ();
|
1810 schuur 1.3
|
1811 mark.hamzy 1.62 for (int i = 0, m = enm.size (); i < m; i++)
|
1812 mark.hamzy 1.37 {
|
1813 mark.hamzy 1.62 enmop->append (CIMObjectPath (String::EMPTY, ns, enm[i]));
|
1814 schuur 1.3 }
|
1815 mark.hamzy 1.62
1816 return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jlong, enmop);
|
1817 schuur 1.3 }
|
1818 mark.hamzy 1.62 Catch (jEnv);
1819
1820 return 0;
|
1821 schuur 1.3 }
|
1822 schuur 1.1
|
1823 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstanceNames
1824 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jboolean deep)
|
1825 mark.hamzy 1.21 {
|
1826 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1827 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
1828
1829 try {
1830 checkNs (cop,jNs);
1831
1832 Array<CIMObjectPath> enm = cCc->enumerateInstanceNames (cop->getNameSpace (),
1833 cop->getClassName ()); //, (Boolean)deep);
|
1834 mark.hamzy 1.21
|
1835 mark.hamzy 1.62 return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jlong, new Array<CIMObjectPath> (enm));
1836 }
1837 Catch (jEnv);
|
1838 mark.hamzy 1.21
|
1839 mark.hamzy 1.62 return 0;
|
1840 mark.hamzy 1.21 }
1841
|
1842 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstances
1843 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jboolean deep, jboolean lo,
1844 jboolean iq, jboolean ic, jobjectArray jPl)
1845 {
1846 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1847 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
1848 CIMPropertyList pl = getList (jEnv,jPl);
1849
1850 try {
1851 checkNs (cop, jNs);
|
1852 schuur 1.1
|
1853 mark.hamzy 1.62 CIMPropertyList props;
1854 Array<CIMInstance> enm = cCc->enumerateInstances (cop->getNameSpace (),
1855 cop->getClassName (),
1856 (Boolean)deep,
1857 (Boolean)lo,
1858 (Boolean)iq,
1859 (Boolean)ic,pl);
|
1860 mark.hamzy 1.20
|
1861 mark.hamzy 1.62 return DEBUG_ConvertCToJava (Array<CIMInstance>*, jlong, new Array<CIMInstance> (enm));
1862 }
1863 Catch (jEnv);
|
1864 mark.hamzy 1.23
|
1865 mark.hamzy 1.62 return 0;
1866 }
|
1867 mark.hamzy 1.23
|
1868 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateQualifiers
1869 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop)
1870 {
1871 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1872 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
|
1873 mark.hamzy 1.54
|
1874 mark.hamzy 1.62 try {
1875 checkNs (cop, jNs);
|
1876 mark.hamzy 1.54
|
1877 mark.hamzy 1.62 Array<CIMQualifierDecl> enm = cCc->enumerateQualifiers (cop->getNameSpace ());
|
1878 mark.hamzy 1.54
|
1879 mark.hamzy 1.62 return DEBUG_ConvertCToJava (Array<CIMQualifierDecl>*, jlong, new Array<CIMQualifierDecl> (enm));
|
1880 schuur 1.1 }
|
1881 mark.hamzy 1.62 Catch (jEnv);
|
1882 mark.hamzy 1.20
|
1883 schuur 1.1 return 0;
1884 }
1885
|
1886 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1getQualifier
1887 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop)
|
1888 mark.hamzy 1.20 {
|
1889 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1890 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
|
1891 r.kieninger 1.11
|
1892 schuur 1.1 try {
|
1893 mark.hamzy 1.62 checkNs (cop,jNs);
1894
1895 CIMQualifierDecl *val = new CIMQualifierDecl (cCc->getQualifier (cop->getNameSpace (),
1896 cop->getClassName ()));
|
1897 mark.hamzy 1.20
|
1898 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMQualifierDecl*, jlong, val);
|
1899 schuur 1.1 }
|
1900 mark.hamzy 1.44 Catch (jEnv);
|
1901 mark.hamzy 1.20
|
1902 schuur 1.1 return 0;
1903 }
1904
|
1905 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setQualifier
1906 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jlong jQ)
|
1907 mark.hamzy 1.20 {
|
1908 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1909 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
1910 CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jlong, CIMQualifierDecl*, jQ);
|
1911 mark.hamzy 1.20
|
1912 mark.hamzy 1.62 try {
1913 checkNs (cop, jNs);
|
1914 mark.hamzy 1.20
|
1915 mark.hamzy 1.62 cCc->setQualifier (cop->getNameSpace (), *qt);
1916 }
1917 Catch (jEnv);
|
1918 schuur 1.1 }
1919
|
1920 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteQualifier
1921 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop)
|
1922 mark.hamzy 1.20 {
|
1923 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1924 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
|
1925 mark.hamzy 1.20
|
1926 mark.hamzy 1.62 try {
1927 checkNs (cop, jNs);
|
1928 mark.hamzy 1.20
|
1929 mark.hamzy 1.62 cCc->deleteQualifier (cop->getNameSpace (), cop->getClassName ());
1930 }
1931 Catch (jEnv);
|
1932 schuur 1.1 }
1933
|
1934 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty
1935 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jstring jPn)
|
1936 mark.hamzy 1.20 {
|
1937 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1938 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
1939 const char *str = jEnv->GetStringUTFChars (jPn, NULL);
1940 CIMName pName (str);
1941 jlong jCv = 0;
|
1942 mark.hamzy 1.20
|
1943 mark.hamzy 1.62 try {
1944 checkNs (cop, jNs);
|
1945 mark.hamzy 1.20
|
1946 mark.hamzy 1.62 CIMValue *val = new CIMValue (cCc->getProperty (cop->getNameSpace (), *cop, pName));
|
1947 schuur 1.1
|
1948 mark.hamzy 1.62 jCv = DEBUG_ConvertCToJava (CIMValue*, jlong, val);
1949 }
1950 Catch (jEnv);
|
1951 mark.hamzy 1.30
|
1952 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jPn, str);
|
1953 schuur 1.5
|
1954 mark.hamzy 1.62 return jCv;
|
1955 schuur 1.1 }
1956
|
1957 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty
1958 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jstring jPn, jlong jV)
|
1959 mark.hamzy 1.20 {
|
1960 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1961 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
1962 CIMValue *val = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);
1963 const char *str = jEnv->GetStringUTFChars (jPn, NULL);
1964 CIMName pName (str);
1965
1966 try {
1967 checkNs (cop,jNs);
|
1968 mark.hamzy 1.20
|
1969 mark.hamzy 1.62 cCc->setProperty (cop->getNameSpace (), *cop, pName, *val);
|
1970 mark.hamzy 1.50 }
1971 Catch (jEnv);
|
1972 mark.hamzy 1.62
1973 jEnv->ReleaseStringUTFChars (jPn, str);
|
1974 schuur 1.5 }
1975
|
1976 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery
1977 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jstring jQuery, jstring jQl)
|
1978 mark.hamzy 1.20 {
|
1979 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
1980 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
1981 const char *str = jEnv->GetStringUTFChars (jQuery, NULL);
1982 String query (str);
|
1983 mark.hamzy 1.30
|
1984 mark.hamzy 1.62 /* @NOTE
1985 ** This does not work for some reason on the client java code:
1986 ** DDD (PEGASUS_STD (cout)<<"--- JMPIjvm::Java_org_pegasus_jmpi_CIMClient__1execQuery: jEnv = "<<PEGASUS_STD (hex)<< (long)jEnv<<", jThs = "<< (long)jThs<<PEGASUS_STD (dec)<<", jCc = "<<jCc<<", jNs = "<<jNs<<", jCop = "<<jCop<<", jQuery = "<<PEGASUS_STD (hex)<< (long)jQuery<<", jQl = "<< (long)jQl<<PEGASUS_STD (dec)<<PEGASUS_STD (endl));
1987 ** What does work is:
1988 ** printf ("This is a test\n");
1989 **
1990 ** To debug these JNI functions insert the following:
1991 ** if (getenv ("PEGASUS_JMPI_GDB"))
1992 ** {
1993 ** bool fLoop = true;
1994 ** int i = 0;
1995 **
1996 ** while (fLoop)
1997 ** {
1998 ** i = 1;
1999 ** }
2000 ** }
2001 ** Export the variable PEGASUS_JMPI_GDB = 1.
2002 ** Start gdb in another process.
2003 ** shell ps -efl
2004 ** att <ps number>
2005 mark.hamzy 1.62 ** set fLoop = 0
2006 */
|
2007 mark.hamzy 1.20
|
2008 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jQuery, str);
|
2009 mark.hamzy 1.20
|
2010 mark.hamzy 1.62 str = jEnv->GetStringUTFChars (jQl, NULL);
|
2011 mark.hamzy 1.20
|
2012 mark.hamzy 1.62 String ql (str);
|
2013 mark.hamzy 1.20
|
2014 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jQl, str);
|
2015 schuur 1.5
|
2016 mark.hamzy 1.62 try {
2017 checkNs (cop, jNs);
|
2018 mark.hamzy 1.30
|
2019 mark.hamzy 1.62 Array<CIMObject> enm = cCc->execQuery (cop->getNameSpace (),
2020 ql,
2021 query);
2022 Array<CIMInstance> *enmInst = new Array<CIMInstance> ();
|
2023 schuur 1.5
|
2024 mark.hamzy 1.62 for (int i = 0,m = enm.size (); i<m; i++)
2025 {
2026 enmInst->append (CIMInstance (enm[i]));
2027 }
|
2028 mark.hamzy 1.20
|
2029 mark.hamzy 1.62 return DEBUG_ConvertCToJava (Array<CIMInstance>*, jlong, enmInst);
|
2030 schuur 1.5 }
|
2031 mark.hamzy 1.62 Catch (jEnv);
|
2032 mark.hamzy 1.20
|
2033 mark.hamzy 1.62 return 0;
|
2034 schuur 1.5 }
2035
|
2036 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod
2037 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jstring jMn, jobject jIn, jobject jOut)
|
2038 mark.hamzy 1.20 {
|
2039 mark.hamzy 1.62 JMPIjvm::cacheIDs (jEnv);
|
2040 mark.hamzy 1.20
|
2041 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
2042 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
2043 const char *str = jEnv->GetStringUTFChars (jMn, NULL);
2044 CIMName method (str);
2045 jlong jCv = 0;
2046 Array<CIMParamValue> in;
2047 Array<CIMParamValue> out;
|
2048 mark.hamzy 1.20
|
2049 mark.hamzy 1.62 for (int i = 0,m = jEnv->CallIntMethod (jIn,JMPIjvm::jv.VectorSize); i<m; i++)
2050 {
2051 JMPIjvm::checkException (jEnv);
|
2052 schuur 1.1
|
2053 mark.hamzy 1.62 jobject jProp = jEnv->CallObjectMethod (jIn,JMPIjvm::jv.VectorElementAt,i);
|
2054 mark.hamzy 1.20
|
2055 mark.hamzy 1.62 JMPIjvm::checkException (jEnv);
|
2056 mark.hamzy 1.20
|
2057 mark.hamzy 1.62 jlong jp = jEnv->CallLongMethod (jProp,JMPIjvm::jv.CIMPropertyCInst);
2058 CIMProperty *p = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jp);
|
2059 schuur 1.1
|
2060 mark.hamzy 1.62 JMPIjvm::checkException (jEnv);
|
2061 mark.hamzy 1.30
|
2062 mark.hamzy 1.62 in.append (CIMParamValue (p->getName ().getString (),p->getValue ()));
2063 }
|
2064 mark.hamzy 1.20
|
2065 mark.hamzy 1.62 try {
2066 checkNs (cop, jNs);
|
2067 mark.hamzy 1.56
|
2068 mark.hamzy 1.62 CIMValue *val = new CIMValue (cCc->invokeMethod (cop->getNameSpace (),*cop,method,in,out));
|
2069 mark.hamzy 1.56
|
2070 mark.hamzy 1.62 for (int i = 0,m = out.size (); i<m; i++)
|
2071 mark.hamzy 1.44 {
|
2072 mark.hamzy 1.62 const CIMParamValue &parm = out[i];
2073 const CIMValue v = parm.getValue ();
2074 CIMProperty *p = new CIMProperty (parm.getParameterName (),v,v.getArraySize ());
2075 jlong jp = DEBUG_ConvertCToJava (CIMProperty*, jlong, p);
2076 jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewJ,jp);
|
2077 mark.hamzy 1.56
|
2078 mark.hamzy 1.62 jEnv->CallVoidMethod (jOut,JMPIjvm::jv.VectorAddElement,prop);
2079 }
|
2080 mark.hamzy 1.20
|
2081 mark.hamzy 1.62 jCv = DEBUG_ConvertCToJava (CIMValue*, jlong, val);
2082 }
2083 Catch (jEnv);
|
2084 mark.hamzy 1.20
|
2085 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jMn,str);
|
2086 mark.hamzy 1.20
|
2087 mark.hamzy 1.62 return jCv;
|
2088 schuur 1.1 }
2089
|
2090 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod24
2091 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jstring jMn,
2092 jobjectArray jIn, jobjectArray jOut)
|
2093 mark.hamzy 1.20 {
|
2094 mark.hamzy 1.62 JMPIjvm::cacheIDs (jEnv);
2095
2096 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
2097 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
2098 const char *str = jEnv->GetStringUTFChars (jMn, NULL);
2099 CIMName method (str);
2100 jlong jCv = 0;
2101 Array<CIMParamValue> in;
2102 Array<CIMParamValue> out;
|
2103 mark.hamzy 1.20
|
2104 mark.hamzy 1.62 if (jIn)
|
2105 mark.hamzy 1.44 {
|
2106 mark.hamzy 1.62 for (int i = 0, m = jEnv->GetArrayLength (jIn); i < m; i++)
2107 {
2108 JMPIjvm::checkException (jEnv);
2109
2110 jobject jArg = jEnv->GetObjectArrayElement (jIn, i);
|
2111 mark.hamzy 1.20
|
2112 mark.hamzy 1.62 JMPIjvm::checkException (jEnv);
|
2113 mark.hamzy 1.20
|
2114 mark.hamzy 1.62 jlong jp = jEnv->CallLongMethod (jArg,JMPIjvm::jv.CIMArgumentCInst);
2115 CIMParamValue *p = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jp);
|
2116 schuur 1.1
|
2117 mark.hamzy 1.62 JMPIjvm::checkException (jEnv);
|
2118 mark.hamzy 1.50
|
2119 mark.hamzy 1.62 in.append (*p);
|
2120 mark.hamzy 1.50 }
2121 }
|
2122 mark.hamzy 1.62 try {
2123 checkNs (cop,jNs);
2124
2125 CIMValue *val = new CIMValue (cCc->invokeMethod (cop->getNameSpace (),
2126 *cop,
2127 method,
2128 in,
2129 out));
|
2130 mark.hamzy 1.20
|
2131 mark.hamzy 1.62 if (jOut)
2132 {
2133 for (int i = 0,m = out.size (),o = jEnv->GetArrayLength (jOut); i<m && i<o; i++)
2134 {
2135 CIMParamValue *parm = new CIMParamValue (out[i]);
2136 jlong jParm = DEBUG_ConvertCToJava (CIMParamValue*, jlong, parm);
|
2137 schuur 1.1
|
2138 mark.hamzy 1.62 jEnv->SetObjectArrayElement (jOut,
2139 i,
2140 jEnv->NewObject (JMPIjvm::jv.CIMArgumentClassRef,JMPIjvm::jv.CIMArgumentNewJ,jParm));
2141 }
2142 }
2143 jCv = DEBUG_ConvertCToJava (CIMValue*, jlong, val);
2144 }
2145 Catch (jEnv);
|
2146 mark.hamzy 1.20
|
2147 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jMn, str);
|
2148 mark.hamzy 1.20
|
2149 mark.hamzy 1.62 return jCv;
|
2150 schuur 1.1 }
2151
|
2152 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1associatorNames
2153 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop,
2154 jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole)
|
2155 mark.hamzy 1.20 {
|
2156 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
2157 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
2158 const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL);
2159
2160 CIMName assocClass;
|
2161 schuur 1.7
|
2162 mark.hamzy 1.62 if ( str
2163 && *str
2164 )
|
2165 mark.hamzy 1.44 {
|
2166 mark.hamzy 1.62 if (CIMName::legal (str))
|
2167 mark.hamzy 1.44 {
|
2168 mark.hamzy 1.62 assocClass = str;
|
2169 mark.hamzy 1.44 }
|
2170 mark.hamzy 1.62 else
|
2171 mark.hamzy 1.44 {
|
2172 mark.hamzy 1.62 jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
2173 JMPIjvm::jv.CIMExceptionNewISt,
2174 (jint)4, // CIM_ERR_INVALID_PARAMETER
2175 jEnv->NewStringUTF ("Invalid association class name"));
|
2176 mark.hamzy 1.44
|
2177 mark.hamzy 1.62 jEnv->Throw ((jthrowable)ev);
|
2178 mark.hamzy 1.23
|
2179 mark.hamzy 1.62 return 0;
2180 }
2181 }
|
2182 mark.hamzy 1.23
|
2183 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jAssocClass,str);
|
2184 mark.hamzy 1.23
|
2185 mark.hamzy 1.62 str = jEnv->GetStringUTFChars (jResultClass, NULL);
|
2186 mark.hamzy 1.23
|
2187 mark.hamzy 1.62 CIMName resultClass;
|
2188 mark.hamzy 1.23
|
2189 mark.hamzy 1.62 if ( str
2190 && *str
2191 )
2192 {
2193 if (CIMName::legal (str))
2194 {
2195 resultClass = str;
|
2196 schuur 1.7 }
|
2197 mark.hamzy 1.62 else
|
2198 mark.hamzy 1.44 {
|
2199 mark.hamzy 1.62 jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
2200 JMPIjvm::jv.CIMExceptionNewISt,
2201 (jint)4, // CIM_ERR_INVALID_PARAMETER
2202 jEnv->NewStringUTF ("Invalid result class name"));
|
2203 mark.hamzy 1.23
|
2204 mark.hamzy 1.62 jEnv->Throw ((jthrowable)ev);
|
2205 mark.hamzy 1.23
|
2206 mark.hamzy 1.62 return 0;
|
2207 schuur 1.7 }
2208 }
|
2209 mark.hamzy 1.23
|
2210 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jResultClass, str);
|
2211 mark.hamzy 1.23
|
2212 mark.hamzy 1.62 str = jEnv->GetStringUTFChars (jRole, NULL);
|
2213 mark.hamzy 1.23
|
2214 mark.hamzy 1.62 String role (str);
|
2215 mark.hamzy 1.23
|
2216 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jRole, str);
|
2217 schuur 1.7
|
2218 mark.hamzy 1.62 str = jEnv->GetStringUTFChars (jResultRole, NULL);
|
2219 schuur 1.7
|
2220 mark.hamzy 1.62 String resultRole (str);
|
2221 schuur 1.1
|
2222 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jResultRole, str);
|
2223 schuur 1.1
|
2224 mark.hamzy 1.62 try {
2225 checkNs (cop,jNs);
|
2226 schuur 1.1
|
2227 mark.hamzy 1.62 Array<CIMObjectPath> enm = cCc->associatorNames (cop->getNameSpace (),
2228 *cop,
2229 assocClass,
2230 resultClass,
2231 role,
2232 resultRole);
2233 return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jlong, new Array<CIMObjectPath> (enm));
2234 }
2235 Catch (jEnv);
|
2236 schuur 1.1
|
2237 mark.hamzy 1.62 return 0;
|
2238 schuur 1.1 }
2239
|
2240 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1associators
2241 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop,
2242 jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole,
2243 jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)
|
2244 mark.hamzy 1.20 {
|
2245 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
2246 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
2247 CIMPropertyList pl = getList (jEnv, jPl);
2248 const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL);
|
2249 mark.hamzy 1.20
|
2250 mark.hamzy 1.62 CIMName assocClass;
|
2251 mark.hamzy 1.27
|
2252 mark.hamzy 1.62 if ( str
2253 && *str
|
2254 mark.hamzy 1.52 )
2255 {
|
2256 mark.hamzy 1.62 if (CIMName::legal (str))
2257 {
2258 assocClass = str;
2259 }
2260 else
2261 {
2262 jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
2263 JMPIjvm::jv.CIMExceptionNewISt,
2264 (jint)4, // CIM_ERR_INVALID_PARAMETER
2265 jEnv->NewStringUTF ("Invalid association class name"));
|
2266 mark.hamzy 1.27
|
2267 mark.hamzy 1.62 jEnv->Throw ((jthrowable)ev);
|
2268 mark.hamzy 1.52
|
2269 mark.hamzy 1.62 return 0;
|
2270 schuur 1.1 }
2271 }
2272
|
2273 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jAssocClass, str);
|
2274 schuur 1.1
|
2275 mark.hamzy 1.62 str = jEnv->GetStringUTFChars (jResultClass, NULL);
|
2276 mark.hamzy 1.52
|
2277 mark.hamzy 1.62 CIMName resultClass;
|
2278 mark.hamzy 1.52
|
2279 mark.hamzy 1.62 if ( str
2280 && *str
2281 )
|
2282 mark.hamzy 1.52 {
|
2283 mark.hamzy 1.62 if (CIMName::legal (str))
2284 {
2285 resultClass = str;
2286 }
2287 else
|
2288 mark.hamzy 1.52 {
|
2289 mark.hamzy 1.62 jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
2290 JMPIjvm::jv.CIMExceptionNewISt,
2291 (jint)4, // CIM_ERR_INVALID_PARAMETER
2292 jEnv->NewStringUTF ("Invalid result class name"));
2293
2294 jEnv->Throw ((jthrowable)ev);
2295
2296 return 0;
2297 }
2298 }
|
2299 mark.hamzy 1.52
|
2300 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jResultClass, str);
|
2301 mark.hamzy 1.52
|
2302 mark.hamzy 1.62 str = jEnv->GetStringUTFChars (jRole, NULL);
|
2303 mark.hamzy 1.52
|
2304 mark.hamzy 1.62 String role (str);
|
2305 mark.hamzy 1.52
|
2306 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jRole, str);
|
2307 mark.hamzy 1.52
|
2308 mark.hamzy 1.62 str = jEnv->GetStringUTFChars (jResultRole, NULL);
|
2309 mark.hamzy 1.52
|
2310 mark.hamzy 1.62 String resultRole (str);
|
2311 schuur 1.5
|
2312 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jResultRole, str);
|
2313 mark.hamzy 1.20
|
2314 schuur 1.1 try {
|
2315 mark.hamzy 1.62 checkNs (cop, jNs);
2316
2317 Array<CIMObject> enm = cCc->associators (cop->getNameSpace (),
2318 *cop,
2319 assocClass,
2320 resultClass,
2321 role,
2322 resultRole,
2323 (Boolean)includeQualifiers,
2324 (Boolean)includeClassOrigin,
2325 pl);
2326 Array<CIMInstance> *enmInst = new Array<CIMInstance> ();
|
2327 mark.hamzy 1.23
|
2328 mark.hamzy 1.62 for (int i = 0,m = enm.size (); i<m; i++)
|
2329 mark.hamzy 1.27 {
|
2330 mark.hamzy 1.62 enmInst->append (CIMInstance (enm[i]));
2331 }
|
2332 mark.hamzy 1.23
|
2333 mark.hamzy 1.62 return DEBUG_ConvertCToJava (Array<CIMInstance>*, jlong, enmInst);
|
2334 schuur 1.1 }
|
2335 mark.hamzy 1.44 Catch (jEnv);
|
2336 mark.hamzy 1.20
|
2337 mark.hamzy 1.62 return 0;
|
2338 schuur 1.1 }
2339
|
2340 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1referenceNames
2341 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop,
2342 jstring jAssocClass, jstring jRole)
|
2343 mark.hamzy 1.20 {
|
2344 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
2345 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
2346 const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL);
|
2347 mark.hamzy 1.30
|
2348 mark.hamzy 1.62 CIMName assocClass;
|
2349 schuur 1.5
|
2350 mark.hamzy 1.62 if ( str
2351 && *str
|
2352 mark.hamzy 1.56 )
|
2353 mark.hamzy 1.52 {
|
2354 mark.hamzy 1.62 if (CIMName::legal (str))
2355 {
2356 assocClass = str;
2357 }
2358 else
2359 {
2360 jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
2361 JMPIjvm::jv.CIMExceptionNewISt,
2362 (jint)4, // CIM_ERR_INVALID_PARAMETER
2363 jEnv->NewStringUTF ("Invalid association class name"));
|
2364 mark.hamzy 1.52
|
2365 mark.hamzy 1.62 jEnv->Throw ((jthrowable)ev);
|
2366 mark.hamzy 1.52
|
2367 mark.hamzy 1.62 return 0;
|
2368 mark.hamzy 1.52 }
|
2369 mark.hamzy 1.62 }
|
2370 mark.hamzy 1.52
|
2371 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jAssocClass, str);
|
2372 mark.hamzy 1.52
|
2373 mark.hamzy 1.62 str = jEnv->GetStringUTFChars (jRole, NULL);
|
2374 mark.hamzy 1.52
|
2375 mark.hamzy 1.62 String role (str);
|
2376 mark.hamzy 1.52
|
2377 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jRole, str);
|
2378 mark.hamzy 1.20
|
2379 mark.hamzy 1.62 try {
2380 checkNs (cop, jNs);
|
2381 mark.hamzy 1.20
|
2382 mark.hamzy 1.62 Array<CIMObjectPath> enm = cCc->referenceNames (cop->getNameSpace (),
2383 *cop,
2384 assocClass,
2385 role);
|
2386 mark.hamzy 1.52
|
2387 mark.hamzy 1.62 return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jlong, new Array<CIMObjectPath> (enm));
|
2388 schuur 1.1 }
|
2389 mark.hamzy 1.62 Catch (jEnv);
|
2390 schuur 1.1
|
2391 mark.hamzy 1.62 return 0;
|
2392 schuur 1.1 }
2393
|
2394 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1references
2395 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop,
2396 jstring jAssocClass, jstring jRole,
2397 jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)
|
2398 mark.hamzy 1.20 {
|
2399 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
2400 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
2401 CIMPropertyList pl = getList (jEnv, jPl);
2402 const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL);
|
2403 mark.hamzy 1.20
|
2404 mark.hamzy 1.62 CIMName assocClass;
|
2405 mark.hamzy 1.20
|
2406 mark.hamzy 1.62 if ( str
2407 && *str
2408 )
2409 {
2410 if (CIMName::legal (str))
2411 {
2412 assocClass = str;
2413 }
2414 else
2415 {
2416 jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
2417 JMPIjvm::jv.CIMExceptionNewISt,
2418 (jint)4, // CIM_ERR_INVALID_PARAMETER
2419 jEnv->NewStringUTF ("Invalid association class name"));
2420
2421 jEnv->Throw ((jthrowable)ev);
|
2422 schuur 1.1
|
2423 mark.hamzy 1.62 return 0;
2424 }
2425 }
|
2426 mark.hamzy 1.20
|
2427 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jAssocClass, str);
2428 str = jEnv->GetStringUTFChars (jRole, NULL);
|
2429 mark.hamzy 1.52
|
2430 mark.hamzy 1.62 String role (str);
|
2431 mark.hamzy 1.52
|
2432 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jRole, str);
|
2433 mark.hamzy 1.52
|
2434 mark.hamzy 1.62 try {
2435 checkNs (cop, jNs);
|
2436 mark.hamzy 1.52
|
2437 mark.hamzy 1.62 Array<CIMObject> enm = cCc->references (cop->getNameSpace (),
2438 *cop,
2439 assocClass,
2440 role,
2441 (Boolean)includeQualifiers,
2442 (Boolean)includeClassOrigin,
2443 pl);
2444 Array<CIMInstance> *enmInst = new Array<CIMInstance> ();
|
2445 mark.hamzy 1.52
|
2446 mark.hamzy 1.62 for (int i = 0, m = enm.size (); i < m; i++)
2447 {
2448 enmInst->append (CIMInstance (enm[i]));
|
2449 mark.hamzy 1.52 }
|
2450 mark.hamzy 1.62
2451 return DEBUG_ConvertCToJava (Array<CIMInstance>*, jlong, enmInst);
|
2452 schuur 1.1 }
|
2453 mark.hamzy 1.62 Catch (jEnv);
|
2454 mark.hamzy 1.20
|
2455 mark.hamzy 1.62 return 0;
|
2456 schuur 1.1 }
2457
|
2458 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createNameSpace
2459 (JNIEnv *jEnv, jobject jThs, jlong jCc, jstring jNs)
|
2460 mark.hamzy 1.20 {
|
2461 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
2462 const char *str = jEnv->GetStringUTFChars (jNs, NULL);
2463 String ns (str);
2464
2465 jEnv->ReleaseStringUTFChars (jNs, str);
2466
2467 String lastNsComp;
2468 String nsBase;
2469
2470 normalizeNs (ns, nsBase, lastNsComp);
2471
2472 CIMInstance newInstance (CIMName ("__Namespace"));
2473 newInstance.addProperty (CIMProperty (CIMName ("name"), lastNsComp));
|
2474 mark.hamzy 1.20
|
2475 mark.hamzy 1.62 try {
2476 cCc->createInstance (CIMNamespaceName (nsBase), newInstance);
2477 }
2478 Catch (jEnv);
|
2479 schuur 1.1 }
2480
|
2481 mark.hamzy 1.62 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateNameSpaces
2482 (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jCop, jboolean deep, jobject jVec)
|
2483 mark.hamzy 1.20 {
|
2484 mark.hamzy 1.44 JMPIjvm::cacheIDs (jEnv);
|
2485 mark.hamzy 1.30
|
2486 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
2487 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
2488 String ns = cop->getNameSpace ().getString ();
2489
2490 try {
2491 Array<CIMObjectPath> enm = cCc->enumerateInstanceNames (cop->getNameSpace (),
2492 CIMName ("__Namespace"));
2493
2494 for (int i = 0, s = enm.size (); i < s; i++)
2495 {
2496 CIMObjectPath& cop = enm[i];
2497 const Array<CIMKeyBinding>& kb = cop.getKeyBindings ();
2498 const String& n = kb[0].getValue ();
|
2499 mark.hamzy 1.16
|
2500 mark.hamzy 1.62 if (!deep && n.find ('/') != PEG_NOT_FOUND)
2501 continue;
|
2502 mark.hamzy 1.16
|
2503 mark.hamzy 1.62 String x = ns+"/"+n;
2504 jstring str = jEnv->NewStringUTF (x.getCString ());
|
2505 mark.hamzy 1.16
|
2506 mark.hamzy 1.62 jEnv->CallVoidMethod (jVec, JMPIjvm::jv.VectorAddElement, str);
2507 }
|
2508 schuur 1.1 }
|
2509 mark.hamzy 1.62 Catch (jEnv);
|
2510 mark.hamzy 1.16
|
2511 schuur 1.1 return jVec;
2512 }
2513
|
2514 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteNameSpace
2515 (JNIEnv *jEnv, jobject jThs, jlong jCc, jstring jNs)
|
2516 mark.hamzy 1.20 {
|
2517 mark.hamzy 1.62 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
2518 const char *str = jEnv->GetStringUTFChars (jNs,NULL);
2519 String ns (str);
|
2520 mark.hamzy 1.20
|
2521 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jNs,str);
|
2522 mark.hamzy 1.20
|
2523 mark.hamzy 1.62 String lastNsComp;
2524 String nsBase;
|
2525 schuur 1.1
|
2526 mark.hamzy 1.62 normalizeNs (ns,nsBase,lastNsComp);
|
2527 schuur 1.7
|
2528 mark.hamzy 1.62 CIMObjectPath cop (String::EMPTY,
2529 CIMNamespaceName (nsBase),
2530 CIMName ("__Namespace"));
2531 Array<CIMKeyBinding> kb;
|
2532 mark.hamzy 1.56
|
2533 mark.hamzy 1.62 kb.append (CIMKeyBinding (("Name"),CIMValue (lastNsComp)));
2534 cop.setKeyBindings (kb);
|
2535 mark.hamzy 1.56
|
2536 mark.hamzy 1.62 try {
2537 cCc->deleteInstance (CIMNamespaceName (nsBase), cop);
|
2538 schuur 1.7 }
|
2539 mark.hamzy 1.62 Catch (jEnv);
2540 }
|
2541 mark.hamzy 1.56
|
2542 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1finalize
2543 (JNIEnv *jEnv, jobject jThs, jlong jCc)
2544 {
2545 CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
|
2546 mark.hamzy 1.56
|
2547 mark.hamzy 1.62 delete cCc;
|
2548 mark.hamzy 1.56
|
2549 mark.hamzy 1.62 DEBUG_ConvertCleanup (jlong, jCc);
2550 }
|
2551 mark.hamzy 1.56
2552
|
2553 mark.hamzy 1.62 // -------------------------------------
2554 // ---
2555 // - CIMDataType
2556 // ---
2557 // -------------------------------------
|
2558 mark.hamzy 1.56
|
2559 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDataType__1new
2560 (JNIEnv *jEnv, jobject jThs, jint type)
2561 {
2562 return DEBUG_ConvertCToJava (_dataType*, jlong, new _dataType (type));
2563 }
|
2564 mark.hamzy 1.56
|
2565 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDataType__1newAr
2566 (JNIEnv *jEnv, jobject jThs, jint type, jint size)
2567 {
2568 return DEBUG_ConvertCToJava (_dataType*, jlong, new _dataType (type,size));
2569 }
|
2570 mark.hamzy 1.56
|
2571 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDataType__1newRef
2572 (JNIEnv *jEnv, jobject jThs, jint type, jstring jRef)
2573 {
2574 const char *ref = jEnv->GetStringUTFChars (jRef,NULL);
2575 jlong cInst = DEBUG_ConvertCToJava (_dataType*, jlong, new _dataType (type,String (ref)));
|
2576 mark.hamzy 1.56
|
2577 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jRef,ref);
|
2578 mark.hamzy 1.56
|
2579 mark.hamzy 1.62 return cInst;
2580 }
|
2581 mark.hamzy 1.56
|
2582 mark.hamzy 1.62 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isReference
2583 (JNIEnv *jEnv, jobject jThs, jlong jDt)
2584 {
2585 _dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);
|
2586 mark.hamzy 1.56
|
2587 mark.hamzy 1.62 return dt->_reference == true;
2588 }
|
2589 mark.hamzy 1.56
|
2590 mark.hamzy 1.62 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isArray
2591 (JNIEnv *jEnv, jobject jThs, jlong jDt)
2592 {
2593 _dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);
|
2594 mark.hamzy 1.56
|
2595 mark.hamzy 1.62 return dt->_array == true;
2596 }
|
2597 mark.hamzy 1.56
|
2598 mark.hamzy 1.62 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getType
2599 (JNIEnv *jEnv, jobject jThs, jlong jDt)
2600 {
2601 _dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);
|
2602 mark.hamzy 1.56
|
2603 mark.hamzy 1.62 return dt->_type;
|
2604 schuur 1.7 }
|
2605 schuur 1.1
|
2606 mark.hamzy 1.62 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getSize
2607 (JNIEnv *jEnv, jobject jThs, jlong jDt)
|
2608 mark.hamzy 1.40 {
|
2609 mark.hamzy 1.62 _dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);
|
2610 mark.hamzy 1.40
|
2611 mark.hamzy 1.62 return dt->_size;
2612 }
|
2613 mark.hamzy 1.40
|
2614 mark.hamzy 1.62 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1getRefClassName
2615 (JNIEnv *jEnv, jobject jThs, jlong jDt)
2616 {
2617 _dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);
2618 jstring str = jEnv->NewStringUTF (dt->_refClass.getCString ());
|
2619 mark.hamzy 1.40
|
2620 mark.hamzy 1.62 return str;
|
2621 mark.hamzy 1.40 }
2622
|
2623 mark.hamzy 1.62 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1toString
2624 (JNIEnv *jEnv, jobject jThs, jlong jDt)
|
2625 mark.hamzy 1.40 {
|
2626 mark.hamzy 1.62 _dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);
2627 jstring str = NULL;
2628
2629 if (dt->_type & 0x10)
2630 {
2631 bool fSuccess = false;
2632 String tmp = _dataType::convertJavaTypeToChars (dt->_type-0x10, &fSuccess);
2633
2634 if (!fSuccess)
2635 return str;
2636
2637 tmp = tmp + "[]";
|
2638 mark.hamzy 1.40
|
2639 mark.hamzy 1.62 str = jEnv->NewStringUTF (tmp.getCString ());
2640 }
2641 else if (dt->_type == 0x20 + 1) // REFERENCE
|
2642 mark.hamzy 1.40 {
|
2643 mark.hamzy 1.62 String tmp = dt->_refClass + " REF";
2644
2645 str = jEnv->NewStringUTF (tmp.getCString ());
|
2646 mark.hamzy 1.40 }
|
2647 mark.hamzy 1.62 else
2648 {
2649 bool fSuccess = false;
2650 char *tmp = _dataType::convertJavaTypeToChars (dt->_type, &fSuccess);
|
2651 mark.hamzy 1.40
|
2652 mark.hamzy 1.62 if (!fSuccess)
2653 return str;
|
2654 mark.hamzy 1.40
|
2655 mark.hamzy 1.62 str = jEnv->NewStringUTF (tmp);
|
2656 mark.hamzy 1.40 }
2657
|
2658 mark.hamzy 1.62 return str;
|
2659 mark.hamzy 1.40 }
2660
|
2661 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDataType__1finalize
2662 (JNIEnv *jEnv, jobject jThs, jlong jDt)
|
2663 mark.hamzy 1.40 {
|
2664 mark.hamzy 1.62 _dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);
|
2665 mark.hamzy 1.40
|
2666 mark.hamzy 1.62 delete dt;
|
2667 mark.hamzy 1.40
|
2668 mark.hamzy 1.62 DEBUG_ConvertCleanup (jlong, jDt);
2669 }
|
2670 mark.hamzy 1.40
2671
|
2672 schuur 1.1 // -------------------------------------
2673 // ---
|
2674 mark.hamzy 1.62 // - CIMDateTime
|
2675 schuur 1.1 // ---
2676 // -------------------------------------
2677
|
2678 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetime
2679 (JNIEnv *jEnv, jobject jThs, jstring jN)
|
2680 mark.hamzy 1.20 {
|
2681 mark.hamzy 1.62 const char *str = jEnv->GetStringUTFChars (jN, NULL);
2682 CIMDateTime *dt = 0;
2683 String date;
2684
2685 if ( str
2686 && *str
2687 )
2688 {
2689 date = str;
2690 }
2691
2692 jEnv->ReleaseStringUTFChars (jN, str);
|
2693 mark.hamzy 1.20
|
2694 mark.hamzy 1.62 try
2695 {
2696 dt = new CIMDateTime (date);
2697 }
2698 Catch (jEnv);
|
2699 mark.hamzy 1.20
|
2700 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMDateTime*, jlong, dt);
|
2701 schuur 1.1 }
2702
|
2703 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetimeempty
|
2704 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs)
2705 {
|
2706 mark.hamzy 1.62 CIMDateTime *dt = new CIMDateTime (CIMDateTime::getCurrentDateTime ());
2707
2708 return DEBUG_ConvertCToJava (CIMDateTime*, jlong, dt);
|
2709 schuur 1.1 }
2710
|
2711 mark.hamzy 1.62 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1after
2712 (JNIEnv *jEnv, jobject jThs, jlong jC, jlong jD)
|
2713 mark.hamzy 1.20 {
|
2714 mark.hamzy 1.62 CIMDateTime *ct = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jC);
2715 CIMDateTime *dt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jD);
|
2716 mark.hamzy 1.67 jboolean rv = 0;
|
2717 mark.hamzy 1.20
|
2718 mark.hamzy 1.62 if ( ct
2719 && dt
2720 )
2721 {
|
2722 mark.hamzy 1.67 rv = (jboolean)(ct->getDifference (*ct, *dt) < 0);
|
2723 mark.hamzy 1.62 }
|
2724 mark.hamzy 1.27
|
2725 mark.hamzy 1.67 return rv;
|
2726 schuur 1.1 }
2727
|
2728 mark.hamzy 1.62 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1before
2729 (JNIEnv *jEnv, jobject jThs, jlong jC, jlong jD)
|
2730 mark.hamzy 1.20 {
|
2731 mark.hamzy 1.62 CIMDateTime *ct = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jC);
2732 CIMDateTime *dt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jD);
|
2733 mark.hamzy 1.67 jboolean rv = 0;
|
2734 schuur 1.1
|
2735 mark.hamzy 1.62 if ( ct
2736 && dt
2737 )
2738 {
|
2739 mark.hamzy 1.67 rv = (jboolean)(ct->getDifference (*ct, *dt) > 0);
|
2740 schuur 1.1 }
2741
|
2742 mark.hamzy 1.67 return rv;
|
2743 schuur 1.1 }
2744
|
2745 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDateTime__1finalize
2746 (JNIEnv *jEnv, jobject jThs, jlong jDT)
|
2747 mark.hamzy 1.20 {
|
2748 mark.hamzy 1.62 CIMDateTime *cdt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jDT);
|
2749 mark.hamzy 1.20
|
2750 mark.hamzy 1.62 delete cdt;
|
2751 mark.hamzy 1.54
|
2752 mark.hamzy 1.62 DEBUG_ConvertCleanup (jlong, jDT);
2753 }
|
2754 mark.hamzy 1.54
2755
|
2756 mark.hamzy 1.62 // -------------------------------------
2757 // ---
2758 // - CIMInstance
2759 // ---
2760 // -------------------------------------
2761
2762 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1new
2763 (JNIEnv *jEnv, jobject jThs)
2764 {
2765 return DEBUG_ConvertCToJava (CIMInstance*, jlong, new CIMInstance ());
2766 }
2767
2768 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1newCn
2769 (JNIEnv *jEnv, jobject jThs, jstring jN)
2770 {
2771 const char *str = jEnv->GetStringUTFChars (jN,NULL);
2772 CIMInstance *ci = new CIMInstance (CIMName (str));
2773
2774 jEnv->ReleaseStringUTFChars (jN,str);
2775
2776 return DEBUG_ConvertCToJava (CIMInstance*, jlong, ci);
|
2777 mark.hamzy 1.54 }
2778
|
2779 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1filterProperties
2780 (JNIEnv *jEnv, jobject jThs, jlong jInst, jobjectArray jPl, jboolean iq, jboolean ic, jboolean lo)
|
2781 mark.hamzy 1.54 {
|
2782 mark.hamzy 1.62 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst);
2783 CIMInstance *cf = 0;
2784 CIMName clsn = ci->getClassName ();
|
2785 mark.hamzy 1.54
|
2786 mark.hamzy 1.62 if (lo)
|
2787 mark.hamzy 1.54 {
|
2788 mark.hamzy 1.62 cf = new CIMInstance (ci->clone ());
2789
2790 CIMName clsn = ci->getClassName ();
2791
2792 for (int i = cf->getPropertyCount () - 1; i >= 0; i--)
2793 {
2794 if (cf->getProperty (i).getClassOrigin () == clsn)
2795 cf->removeProperty (i);
2796 }
2797
2798 return DEBUG_ConvertCToJava (CIMInstance*, jlong, cf);
|
2799 mark.hamzy 1.54 }
|
2800 mark.hamzy 1.62 else if (jPl)
|
2801 mark.hamzy 1.54 {
|
2802 mark.hamzy 1.62 CIMPropertyList pl = getList (jEnv, jPl);
2803 Array<CIMName> n = pl.getPropertyNameArray ();
|
2804 mark.hamzy 1.54
|
2805 mark.hamzy 1.62 cf = new CIMInstance (clsn);
|
2806 mark.hamzy 1.54
|
2807 mark.hamzy 1.62 for (int i = 0, s = n.size (); i < s; i++)
|
2808 mark.hamzy 1.54 {
|
2809 mark.hamzy 1.62 Uint32 pos = ci->findProperty (n[i]);
|
2810 mark.hamzy 1.54
|
2811 mark.hamzy 1.62 if (pos != PEG_NOT_FOUND)
|
2812 mark.hamzy 1.54 {
|
2813 mark.hamzy 1.62 if (iq)
|
2814 mark.hamzy 1.54 {
|
2815 mark.hamzy 1.62 CIMProperty cp = ci->getProperty (pos).clone ();
2816
2817 if (!ic)
2818 cp.setClassOrigin (CIMName ());
2819
2820 cf->addProperty (cp);
|
2821 mark.hamzy 1.54 }
2822 else
2823 {
|
2824 mark.hamzy 1.62 CIMProperty cp = ci->getProperty (pos);
2825 CIMName co;
2826
2827 if (ic)
2828 co = cp.getClassOrigin ();
2829
2830 CIMProperty np (cp.getName (),
2831 cp.getValue (),
2832 cp.getArraySize (),
2833 cp.getReferenceClassName (),
2834 co,
2835 cp.getPropagated ());
2836
2837 cf->addProperty (np);
|
2838 mark.hamzy 1.54 }
2839 }
2840 }
|
2841 mark.hamzy 1.62
2842 cf->setPath (ci->getPath ());
|
2843 mark.hamzy 1.54 }
|
2844 mark.hamzy 1.62 else if (iq)
2845 {
2846 cf = new CIMInstance (ci->clone ());
2847
2848 if (ic)
2849 return DEBUG_ConvertCToJava (CIMInstance*, jlong, cf);
|
2850 mark.hamzy 1.20
|
2851 mark.hamzy 1.62 for (int i = cf->getPropertyCount () - 1; i >= 0; i--)
2852 {
2853 CIMProperty cp = cf->getProperty (i);
|
2854 schuur 1.1
|
2855 mark.hamzy 1.62 cp.setClassOrigin (CIMName ());
2856 cf->removeProperty (i);
2857 cf->addProperty (cp);
2858 }
2859 }
2860 else
2861 {
2862 cf = new CIMInstance (clsn);
|
2863 mark.hamzy 1.20
|
2864 mark.hamzy 1.62 for (int i = ci->getPropertyCount () - 1; i >= 0; i--)
2865 {
2866 CIMProperty cp = ci->getProperty (i);
2867 CIMName co;
|
2868 mark.hamzy 1.20
|
2869 mark.hamzy 1.62 if (ic)
2870 co = cp.getClassOrigin ();
|
2871 schuur 1.1
|
2872 mark.hamzy 1.62 CIMProperty np (cp.getName (),
2873 cp.getValue (),
2874 cp.getArraySize (),
2875 cp.getReferenceClassName (),
2876 co,
2877 cp.getPropagated ());
|
2878 mark.hamzy 1.20
|
2879 mark.hamzy 1.62 cf->addProperty (np);
2880 }
2881 cf->setPath (ci->getPath ());
2882 }
|
2883 mark.hamzy 1.20
|
2884 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMInstance*, jlong, cf);
|
2885 schuur 1.1 }
2886
|
2887 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setName
2888 (JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jN)
|
2889 mark.hamzy 1.20 {
|
2890 mark.hamzy 1.62 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst);
2891 const char *str = jEnv->GetStringUTFChars (jN, NULL);
|
2892 mark.hamzy 1.20
|
2893 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jN,str);
|
2894 mark.hamzy 1.27
|
2895 mark.hamzy 1.62 /* NOT SUPPORTED AND NOT NEEDED*/
|
2896 schuur 1.1 }
2897
|
2898 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperty
2899 (JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jN, jlong jV)
|
2900 mark.hamzy 1.20 {
|
2901 mark.hamzy 1.62 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst);
2902 CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);
2903 const char *str = jEnv->GetStringUTFChars (jN, NULL);
2904 Uint32 pos;
2905
2906 if ( ci
2907 && cv
2908 )
2909 {
2910 try {
2911 pos = ci->findProperty (CIMName (str));
|
2912 mark.hamzy 1.20
|
2913 mark.hamzy 1.62 if (pos != PEG_NOT_FOUND)
2914 {
2915 CIMProperty cp = ci->getProperty (pos);
|
2916 mark.hamzy 1.20
|
2917 mark.hamzy 1.62 if (cp.getType () == cv->getType ())
2918 {
2919 cp.setValue (*cv);
2920 }
2921 else
2922 {
2923 throw CIMException (CIM_ERR_TYPE_MISMATCH, String ("Property type mismatch"));
2924 }
|
2925 schuur 1.1
|
2926 mark.hamzy 1.62 ci->removeProperty (pos);
2927 ci->addProperty (cp);
2928 }
2929 else
2930 {
2931 CIMProperty *cp = new CIMProperty (CIMName (str), *cv);
|
2932 mark.hamzy 1.20
|
2933 mark.hamzy 1.62 ci->addProperty (*cp);
2934 }
2935 }
2936 Catch (jEnv);
2937 }
|
2938 mark.hamzy 1.27
|
2939 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jN, str);
|
2940 schuur 1.1 }
2941
|
2942 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperties
2943 (JNIEnv *jEnv, jobject jThs, jlong jInst, jobject jV)
|
2944 mark.hamzy 1.20 {
|
2945 mark.hamzy 1.62 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst);
|
2946 mark.hamzy 1.20
|
2947 mark.hamzy 1.62 if (!ci)
2948 {
2949 return;
2950 }
|
2951 mark.hamzy 1.20
|
2952 mark.hamzy 1.62 try
2953 {
2954 for (int i = 0, m = jEnv->CallIntMethod (jV,
2955 JMPIjvm::jv.VectorSize);
2956 i < m;
2957 i++)
2958 {
2959 JMPIjvm::checkException (jEnv);
|
2960 schuur 1.1
|
2961 mark.hamzy 1.62 jobject jProp = jEnv->CallObjectMethod (jV,
2962 JMPIjvm::jv.VectorElementAt,
2963 i);
|
2964 mark.hamzy 1.20
|
2965 mark.hamzy 1.62 JMPIjvm::checkException (jEnv);
|
2966 mark.hamzy 1.27
|
2967 mark.hamzy 1.62 jlong jCpRef = jEnv->CallLongMethod (jProp, JMPIjvm::jv.CIMPropertyCInst);
2968 CIMProperty *cpNew = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jCpRef);
|
2969 schuur 1.1
|
2970 mark.hamzy 1.62 if (cpNew)
2971 {
2972 Uint32 pos = ci->findProperty (cpNew->getName ());
|
2973 mark.hamzy 1.20
|
2974 mark.hamzy 1.62 if (pos != PEG_NOT_FOUND)
2975 {
2976 CIMProperty cpOld = ci->getProperty (pos);
|
2977 mark.hamzy 1.27
|
2978 mark.hamzy 1.62 if (cpOld.getType () == cpNew->getType ())
2979 {
2980 ci->removeProperty (pos);
2981 ci->addProperty (*cpNew);
2982 }
2983 else
2984 {
2985 throw CIMException (CIM_ERR_TYPE_MISMATCH, String ("Property type mismatch"));
2986 }
2987 }
2988 }
2989 }
2990 }
2991 Catch (jEnv);
|
2992 schuur 1.1 }
2993
|
2994 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperty
2995 (JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jN)
|
2996 mark.hamzy 1.20 {
|
2997 mark.hamzy 1.62 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst);
2998 const char *str = jEnv->GetStringUTFChars (jN, NULL);
2999 jlong rv = 0;
|
3000 mark.hamzy 1.30
|
3001 mark.hamzy 1.62 try {
3002 Uint32 pos = ci->findProperty (CIMName (str));
|
3003 schuur 1.1
|
3004 mark.hamzy 1.62 if (pos != PEG_NOT_FOUND)
3005 {
3006 CIMProperty *cp = new CIMProperty (ci->getProperty (pos));
|
3007 mark.hamzy 1.56
|
3008 mark.hamzy 1.62 rv = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp);
|
3009 schuur 1.1 }
|
3010 mark.hamzy 1.62 }
3011 Catch (jEnv);
|
3012 r.kieninger 1.11
|
3013 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jN, str);
|
3014 mark.hamzy 1.56
|
3015 mark.hamzy 1.62 return rv;
|
3016 schuur 1.1 }
3017
|
3018 mark.hamzy 1.62 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getKeyValuePairs
3019 (JNIEnv *jEnv, jobject jThs, jlong jInst, jobject jVec)
|
3020 mark.hamzy 1.20 {
|
3021 mark.hamzy 1.62 JMPIjvm::cacheIDs (jEnv);
3022
3023 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst);
|
3024 mark.hamzy 1.20
|
3025 mark.hamzy 1.62 if ( ci
3026 && CIMNamespaceName::legal (ci->getPath ().getNameSpace ().getString ())
3027 )
|
3028 mark.hamzy 1.27 {
|
3029 mark.hamzy 1.62 CIMOMHandle ch;
3030 OperationContext oc;
3031 CIMClass cc;
3032
3033 cc = ch.getClass (oc,
3034 ci->getPath ().getNameSpace (),
3035 ci->getClassName (),
3036 false, // localOnly
3037 true, // includeQualifiers
3038 true, // includeClassOrigin
3039 CIMPropertyList ()); // propertyList
|
3040 mark.hamzy 1.27
|
3041 mark.hamzy 1.62 if (!cc.hasKeys ())
|
3042 mark.hamzy 1.27 {
|
3043 mark.hamzy 1.62 return jVec;
|
3044 schuur 1.1 }
|
3045 mark.hamzy 1.20
|
3046 mark.hamzy 1.62 Array<CIMName> keyNames;
3047
3048 cc.getKeyNames (keyNames);
3049
3050 for (Uint32 i = 0; i < keyNames.size (); i++)
3051 {
3052 DDD(PEGASUS_STD (cout) << "finding key " << keyNames[i].getString () << PEGASUS_STD (endl));
|
3053 mark.hamzy 1.20
|
3054 mark.hamzy 1.62 for (Uint32 j = 0; j < ci->getPropertyCount (); j++)
3055 {
3056 CIMProperty cp = ci->getProperty (j);
|
3057 schuur 1.1
|
3058 mark.hamzy 1.62 if (cp.getName () == keyNames[i])
3059 {
3060 DDD(PEGASUS_STD (cout) << "adding key (" << j << ") " << keyNames[i].getString () << PEGASUS_STD (endl));
|
3061 mark.hamzy 1.20
|
3062 mark.hamzy 1.62 CIMProperty *cpRef = new CIMProperty (cp);
3063 jlong jCpRef = DEBUG_ConvertCToJava (CIMProperty*, jlong, cpRef);
3064 jobject jProp = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,
3065 JMPIjvm::jv.CIMPropertyNewJ,
3066 jCpRef);
|
3067 mark.hamzy 1.27
|
3068 mark.hamzy 1.62 jEnv->CallVoidMethod (jVec,
3069 JMPIjvm::jv.VectorAddElement,
3070 jProp);
3071 }
3072 }
3073 }
3074 }
|
3075 mark.hamzy 1.20
|
3076 mark.hamzy 1.62 return jVec;
|
3077 schuur 1.1 }
3078
|
3079 mark.hamzy 1.62 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperties
3080 (JNIEnv *jEnv, jobject jThs, jlong jInst, jobject jVec)
|
3081 mark.hamzy 1.20 {
|
3082 mark.hamzy 1.44 JMPIjvm::cacheIDs (jEnv);
|
3083 mark.hamzy 1.30
|
3084 mark.hamzy 1.62 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst);
|
3085 mark.hamzy 1.20
|
3086 mark.hamzy 1.62 for (int i = 0, s = ci->getPropertyCount (); i < s; i++)
|
3087 mark.hamzy 1.44 {
|
3088 mark.hamzy 1.62 CIMProperty *cp = new CIMProperty (ci->getProperty (i));
3089 jlong jCp = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp);
3090
3091 jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewJ,jCp);
|
3092 mark.hamzy 1.20
|
3093 mark.hamzy 1.62 jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,prop);
|
3094 schuur 1.1 }
|
3095 mark.hamzy 1.56
|
3096 mark.hamzy 1.62 return jVec;
|
3097 schuur 1.1 }
3098
|
3099 mark.hamzy 1.62 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMInstance__1getClassName
3100 (JNIEnv *jEnv, jobject jThs, jlong jInst)
|
3101 mark.hamzy 1.20 {
|
3102 mark.hamzy 1.62 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst);
3103 const String &cn = ci->getClassName ().getString ();
3104
3105 jstring str = jEnv->NewStringUTF (cn.getCString ());
|
3106 mark.hamzy 1.20
|
3107 mark.hamzy 1.62 return str;
|
3108 schuur 1.1 }
3109
|
3110 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1getQualifier
3111 (JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jN)
|
3112 mark.hamzy 1.20 {
|
3113 mark.hamzy 1.62 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst);
3114 const char *str = jEnv->GetStringUTFChars (jN, NULL);
3115 jlong rv = 0;
3116 Uint32 pos;
|
3117 mark.hamzy 1.20
|
3118 mark.hamzy 1.62 if (ci)
3119 {
3120 try
3121 {
3122 CIMOMHandle ch;
3123 OperationContext oc;
3124 CIMClass cc;
|
3125 mark.hamzy 1.20
|
3126 mark.hamzy 1.62 cc = ch.getClass (oc,
3127 ci->getPath ().getNameSpace (),
3128 ci->getClassName (),
3129 false, // localOnly
3130 true, // includeQualifiers
3131 true, // includeClassOrigin
3132 CIMPropertyList ()); // propertyList
|
3133 schuur 1.1
|
3134 mark.hamzy 1.62 pos = cc.findQualifier (String (str));
|
3135 schuur 1.1
|
3136 mark.hamzy 1.62 if (pos != PEG_NOT_FOUND)
3137 {
3138 CIMQualifier *cq = 0;
|
3139 schuur 1.1
|
3140 mark.hamzy 1.62 cq = new CIMQualifier (cc.getQualifier (pos));
|
3141 schuur 1.1
|
3142 mark.hamzy 1.62 rv = DEBUG_ConvertCToJava (CIMQualifier*, jlong, cq);
3143 }
3144 }
3145 Catch (jEnv);
3146 }
|
3147 mark.hamzy 1.20
|
3148 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jN, str);
|
3149 mark.hamzy 1.20
|
3150 mark.hamzy 1.62 return rv;
|
3151 schuur 1.1 }
3152
|
3153 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1clone
3154 (JNIEnv *jEnv, jobject jThs, jlong jInst)
|
3155 mark.hamzy 1.20 {
|
3156 mark.hamzy 1.62 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst);
3157 CIMInstance *cl = new CIMInstance (ci->clone ());
|
3158 mark.hamzy 1.20
|
3159 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMInstance*, jlong, cl);
|
3160 schuur 1.1 }
3161
|
3162 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1finalize
3163 (JNIEnv *jEnv, jobject jThs, jlong jInst)
|
3164 mark.hamzy 1.20 {
|
3165 mark.hamzy 1.62 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst);
|
3166 mark.hamzy 1.20
|
3167 mark.hamzy 1.62 delete ci;
|
3168 schuur 1.1
|
3169 mark.hamzy 1.62 DEBUG_ConvertCleanup (jlong, jInst);
|
3170 schuur 1.1 }
3171
|
3172 mark.hamzy 1.62 /*
3173 * Class: org_pegasus_jmpi_CIMInstance
3174 * Method: _getObjectPath
3175 * Signature: (I)I
3176 */
3177 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1getObjectPath
3178 (JNIEnv *jEnv, jobject jThs, jlong jciCi)
|
3179 mark.hamzy 1.20 {
|
3180 mark.hamzy 1.62 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciCi);
3181 CIMObjectPath *copRet = NULL;
3182
3183 try
3184 {
3185 if (ci)
3186 {
3187 const CIMObjectPath& cop = ci->getPath ();
3188
3189 copRet = new CIMObjectPath (cop);
3190 }
3191 }
3192 Catch (jEnv);
|
3193 mark.hamzy 1.20
|
3194 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, copRet);
|
3195 schuur 1.1 }
3196
|
3197 mark.hamzy 1.62 /*
3198 * Class: org_pegasus_jmpi_CIMInstance
3199 * Method: _setObjectPath
3200 * Signature: (II)V
3201 */
3202 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setObjectPath
3203 (JNIEnv *jEnv, jobject jThs, jlong jciCi, jlong jciCop)
|
3204 mark.hamzy 1.20 {
|
3205 mark.hamzy 1.62 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciCi);
3206 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jciCop);
|
3207 mark.hamzy 1.20
|
3208 mark.hamzy 1.62 try
3209 {
3210 if ( ci
3211 && cop
3212 )
3213 {
3214 ci->setPath (*cop);
3215 }
3216 }
3217 Catch (jEnv);
|
3218 schuur 1.1 }
3219
|
3220 mark.hamzy 1.62 /*
3221 * Class: org_pegasus_jmpi_CIMInstance
3222 * Method: _getPropertyCount
3223 * Signature: (I)I
3224 */
3225 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getPropertyCount
3226 (JNIEnv *jEnv, jobject jThs, jlong jciCi)
|
3227 mark.hamzy 1.20 {
|
3228 mark.hamzy 1.62 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciCi);
3229 Uint32 ui32Ret = 0;
|
3230 mark.hamzy 1.20
|
3231 mark.hamzy 1.62 try
|
3232 mark.hamzy 1.35 {
|
3233 mark.hamzy 1.62 if (ci)
3234 {
3235 ui32Ret = ci->getPropertyCount ();
3236 }
3237 }
3238 Catch (jEnv);
|
3239 mark.hamzy 1.35
|
3240 mark.hamzy 1.62 return ui32Ret;
3241 }
|
3242 mark.hamzy 1.35
|
3243 mark.hamzy 1.62 /*
3244 * Class: org_pegasus_jmpi_CIMInstance
3245 * Method: _getProperty
3246 * Signature: (II)I
3247 */
3248 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1getPropertyI
3249 (JNIEnv *jEnv, jobject jThs, jlong jciCi, jint ji)
3250 {
3251 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciCi);
3252 CIMProperty *cpRet = NULL;
|
3253 mark.hamzy 1.35
|
3254 mark.hamzy 1.62 try
|
3255 mark.hamzy 1.35 {
|
3256 mark.hamzy 1.62 if (ci)
3257 {
3258 CIMProperty cp;
3259
3260 cp = ci->getProperty (ji);
|
3261 mark.hamzy 1.35
|
3262 mark.hamzy 1.62 cpRet = new CIMProperty (cp);
3263 }
|
3264 schuur 1.6 }
|
3265 mark.hamzy 1.62 Catch (jEnv);
3266
3267 return DEBUG_ConvertCToJava (CIMProperty*, jlong, cpRet);
3268 }
3269
3270
3271 // -------------------------------------
3272 // ---
3273 // - CIMMethod
3274 // ---
3275 // -------------------------------------
3276
3277 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1getType
3278 (JNIEnv *jEnv, jobject jThs, jlong jM)
3279 {
3280 CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);
3281 bool fSuccess = false;
3282 jint jType = 0;
3283
3284 if (cm)
|
3285 mark.hamzy 1.35 {
|
3286 mark.hamzy 1.62 CIMType ct = cm->getType ();
|
3287 mark.hamzy 1.35
|
3288 mark.hamzy 1.62 jType = _dataType::convertCTypeToJavaType (ct, &fSuccess);
|
3289 schuur 1.1 }
|
3290 mark.hamzy 1.20
|
3291 mark.hamzy 1.62 return jType;
|
3292 schuur 1.1 }
3293
|
3294 mark.hamzy 1.67 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMMethod__1getName
3295 (JNIEnv *jEnv, jobject jThs, jlong jM)
3296 {
3297 CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);
3298 jstring str = 0;
3299
3300 if (cm)
3301 {
3302 CIMName cn = cm->getName ();
3303
3304 str = jEnv->NewStringUTF (cn.getString ().getCString ());
3305 }
3306
3307 return str;
3308 }
3309
3310 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1findParameter
3311 (JNIEnv *jEnv, jobject jThs, jlong jM, jstring jName)
3312 {
3313 CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);
3314 jint rv = -1;
3315 mark.hamzy 1.67
3316 if (cm && jName)
3317 {
3318 const char *cstrName = jEnv->GetStringUTFChars (jName, NULL);
3319
3320 try
3321 {
3322 CIMName name (cstrName);
3323
3324 rv = cm->findParameter (name);
3325 }
3326 Catch (jEnv);
3327
3328 jEnv->ReleaseStringUTFChars (jName, cstrName);
3329 }
3330
3331 return rv;
3332 }
3333
3334 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMMethod__1getParameter
3335 (JNIEnv *jEnv, jobject jThs, jlong jM, jint jParameter)
3336 mark.hamzy 1.67 {
3337 CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);
3338 jlong rv = 0;
3339
3340 if (cm && jParameter >= 0)
3341 {
3342 try
3343 {
3344 CIMParameter cp = cm->getParameter (jParameter);
3345
3346 rv = DEBUG_ConvertCToJava (CIMParameter *, jlong, new CIMParameter (cp));
3347 }
3348 Catch (jEnv);
3349 }
3350
3351 return rv;
3352 }
3353
3354 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMMethod__1getParameterCount
3355 (JNIEnv *jEnv, jobject jThs, jlong jM)
3356 {
3357 mark.hamzy 1.67 CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);
3358 jint rv = 0;
3359
3360 if (cm)
3361 {
3362 try
3363 {
3364 rv = cm->getParameterCount ();
3365 }
3366 Catch (jEnv);
3367 }
3368
3369 return rv;
3370 }
3371
|
3372 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize
3373 (JNIEnv *jEnv, jobject jThs, jlong jM)
|
3374 mark.hamzy 1.24 {
|
3375 mark.hamzy 1.62 CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);
|
3376 mark.hamzy 1.24
|
3377 mark.hamzy 1.62 delete cm;
|
3378 mark.hamzy 1.24
|
3379 mark.hamzy 1.62 DEBUG_ConvertCleanup (jlong, jM);
|
3380 mark.hamzy 1.24 }
3381
|
3382 schuur 1.1
3383 // -------------------------------------
3384 // ---
|
3385 mark.hamzy 1.62 // - CIMNameSpace
|
3386 schuur 1.6 // ---
3387 // -------------------------------------
3388
|
3389 mark.hamzy 1.62 _nameSpace::_nameSpace ()
|
3390 mark.hamzy 1.20 {
|
3391 mark.hamzy 1.62 port_ = 0;
3392 hostName_ = System::getHostName ();
3393 nameSpace_ = "root/cimv2";
|
3394 mark.hamzy 1.66 fHttps = false;
|
3395 mark.hamzy 1.62 }
|
3396 mark.hamzy 1.20
|
3397 mark.hamzy 1.62 _nameSpace::_nameSpace (String hn)
3398 {
3399 port_ = 0;
3400 hostName_ = hn;
3401 nameSpace_ = "root/cimv2";
|
3402 mark.hamzy 1.66 fHttps = false;
|
3403 schuur 1.6 }
3404
|
3405 mark.hamzy 1.62 _nameSpace::_nameSpace (String hn, String ns)
|
3406 mark.hamzy 1.20 {
|
3407 mark.hamzy 1.62 port_ = 0;
3408 hostName_ = hn;
3409 nameSpace_ = ns;
|
3410 mark.hamzy 1.66 fHttps = false;
|
3411 schuur 1.6 }
3412
|
3413 mark.hamzy 1.62 int _nameSpace::port ()
|
3414 mark.hamzy 1.20 {
|
3415 mark.hamzy 1.62 if (port_)
3416 return port_;
|
3417 mark.hamzy 1.20
|
3418 mark.hamzy 1.62 port_ = 5988;
|
3419 mark.hamzy 1.20
|
3420 mark.hamzy 1.62 if (hostName_.subString (0,7) == "http://")
3421 {
|
3422 mark.hamzy 1.66 protocol_ = hostName_.subString (0,7);
|
3423 mark.hamzy 1.62 hostName_ = hostName_.subString (7);
3424 }
|
3425 mark.hamzy 1.66 else if (hostName_.subString (0,8) == "https://")
3426 {
3427 protocol_ = hostName_.subString (0,8);
3428 hostName_ = hostName_.subString (8);
3429 fHttps = true;
3430 }
|
3431 schuur 1.6
|
3432 mark.hamzy 1.62 Sint32 p = hostName_.reverseFind (':');
|
3433 mark.hamzy 1.20
|
3434 mark.hamzy 1.62 if (p >= 0)
|
3435 mark.hamzy 1.49 {
|
3436 mark.hamzy 1.62 if ((hostName_[p+1] >= '0') && (hostName_[p+1] <= '9'))
3437 port_ = atoi (hostName_.subString (p+1).getCString ());
3438
3439 hostName_.remove (p);
|
3440 mark.hamzy 1.49 }
3441
|
3442 mark.hamzy 1.62 return port_;
3443 }
|
3444 mark.hamzy 1.20
|
3445 mark.hamzy 1.62 String _nameSpace::hostName ()
3446 {
3447 port ();
3448 return hostName_;
|
3449 schuur 1.6 }
3450
|
3451 mark.hamzy 1.62 String _nameSpace::nameSpace ()
|
3452 mark.hamzy 1.20 {
|
3453 mark.hamzy 1.62 return nameSpace_;
3454 }
|
3455 mark.hamzy 1.20
|
3456 mark.hamzy 1.66 Boolean _nameSpace::isHttps ()
3457 {
3458 port ();
3459 return fHttps;
3460 }
3461
|
3462 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1new
3463 (JNIEnv *jEnv, jobject jThs)
3464 {
3465 return DEBUG_ConvertCToJava (_nameSpace*, jlong, new _nameSpace ());
|
3466 schuur 1.6 }
3467
|
3468 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHn
3469 (JNIEnv *jEnv, jobject jThs, jstring jHn)
|
3470 mark.hamzy 1.20 {
|
3471 mark.hamzy 1.62 const char *hn = jEnv->GetStringUTFChars (jHn, NULL);
3472 jlong cInst = DEBUG_ConvertCToJava (_nameSpace*, jlong, new _nameSpace (hn));
3473
3474 jEnv->ReleaseStringUTFChars (jHn, hn);
|
3475 mark.hamzy 1.20
|
3476 mark.hamzy 1.62 return cInst;
|
3477 schuur 1.6 }
3478
|
3479 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHnNs
3480 (JNIEnv *jEnv, jobject jThs, jstring jHn, jstring jNs)
|
3481 mark.hamzy 1.20 {
|
3482 mark.hamzy 1.62 const char *hn = jEnv->GetStringUTFChars (jHn, NULL);
3483 const char *ns = jEnv->GetStringUTFChars (jNs, NULL);
3484 jlong cInst = DEBUG_ConvertCToJava (_nameSpace*, jlong, new _nameSpace (String (hn),String (ns)));
|
3485 mark.hamzy 1.20
|
3486 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jHn, hn);
3487 jEnv->ReleaseStringUTFChars (jNs, ns);
|
3488 mark.hamzy 1.27
|
3489 mark.hamzy 1.62 return cInst;
|
3490 schuur 1.6 }
3491
|
3492 mark.hamzy 1.62 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getNameSpace
3493 (JNIEnv *jEnv, jobject jThs, jlong jNs)
|
3494 mark.hamzy 1.20 {
|
3495 mark.hamzy 1.62 _nameSpace *cNs = DEBUG_ConvertJavaToC (jlong, _nameSpace*, jNs);
3496 const String &ns = cNs->nameSpace_;
3497 jstring str = jEnv->NewStringUTF (ns.getCString ());
|
3498 mark.hamzy 1.35
|
3499 mark.hamzy 1.62 return str;
3500 }
3501
3502 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getHost
3503 (JNIEnv *jEnv, jobject jThs, jlong jNs)
3504 {
3505 _nameSpace *cNs = DEBUG_ConvertJavaToC (jlong, _nameSpace*, jNs);
3506 const String &hn = cNs->hostName_;
3507 jstring str = jEnv->NewStringUTF (hn.getCString ());
3508
3509 return str;
3510 }
3511
3512 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setNameSpace
3513 (JNIEnv *jEnv, jobject jThs, jlong jNs, jstring jN)
3514 {
3515 _nameSpace *cNs = DEBUG_ConvertJavaToC (jlong, _nameSpace*, jNs);
3516 const char *str = jEnv->GetStringUTFChars (jN, NULL);
3517
3518 cNs->nameSpace_ = str;
3519
3520 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jN, str);
3521 }
3522
3523 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setHost
3524 (JNIEnv *jEnv, jobject jThs, jlong jNs, jstring jHn)
3525 {
3526 _nameSpace *cNs = DEBUG_ConvertJavaToC (jlong, _nameSpace*, jNs);
3527 const char *str = jEnv->GetStringUTFChars (jHn, NULL);
3528
3529 cNs->port_ = 0;
3530 cNs->hostName_ = str;
3531
3532 jEnv->ReleaseStringUTFChars (jHn, str);
3533 }
3534
3535 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1finalize
3536 (JNIEnv *jEnv, jobject jThs, jlong jNs)
3537 {
3538 _nameSpace *cNs = DEBUG_ConvertJavaToC (jlong, _nameSpace*, jNs);
|
3539 mark.hamzy 1.35
|
3540 mark.hamzy 1.62 delete cNs;
|
3541 mark.hamzy 1.20
|
3542 mark.hamzy 1.62 DEBUG_ConvertCleanup (jlong, jNs);
|
3543 schuur 1.6 }
3544
|
3545 mark.hamzy 1.51
|
3546 schuur 1.6 // -------------------------------------
3547 // ---
|
3548 mark.hamzy 1.62 // - CIMObject
|
3549 schuur 1.1 // ---
3550 // -------------------------------------
3551
|
3552 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObject__1newClass
3553 (JNIEnv *jEnv, jobject jThs, jlong jCc)
|
3554 mark.hamzy 1.20 {
|
3555 mark.hamzy 1.62 CIMClass *cCc = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCc);
|
3556 mark.hamzy 1.20
|
3557 mark.hamzy 1.62 try {
3558 CIMObject *cCo = new CIMObject (*cCc);
|
3559 schuur 1.1
|
3560 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMObject*, jlong, cCo);
3561 }
3562 Catch (jEnv);
|
3563 mark.hamzy 1.20
|
3564 mark.hamzy 1.62 return 0;
|
3565 schuur 1.5 }
3566
|
3567 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObject__1newInstance
3568 (JNIEnv *jEnv, jobject jThs, jlong jCi)
|
3569 mark.hamzy 1.20 {
|
3570 mark.hamzy 1.62 CIMInstance *cCi = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jCi);
|
3571 mark.hamzy 1.27
|
3572 schuur 1.1 try {
|
3573 mark.hamzy 1.62 CIMObject *cCo = new CIMObject (*cCi);
|
3574 mark.hamzy 1.27
|
3575 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMObject*, jlong, cCo);
|
3576 schuur 1.1 }
|
3577 mark.hamzy 1.44 Catch (jEnv);
|
3578 mark.hamzy 1.20
|
3579 mark.hamzy 1.62 return 0;
3580 }
3581
3582 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObject__1finalize
3583 (JNIEnv *jEnv, jobject jThs, jlong jInst)
3584 {
3585 CIMObject *co = DEBUG_ConvertJavaToC (jlong, CIMObject*, jInst);
3586
3587 delete co;
|
3588 mark.hamzy 1.27
|
3589 mark.hamzy 1.62 DEBUG_ConvertCleanup (jlong, jInst);
|
3590 schuur 1.1 }
3591
|
3592 mark.hamzy 1.62
3593 // -------------------------------------
3594 // ---
3595 // - CIMObjectPath
3596 // ---
3597 // -------------------------------------
3598
3599 CIMObjectPath* construct ()
|
3600 mark.hamzy 1.20 {
|
3601 mark.hamzy 1.62 CIMObjectPath *cop = new CIMObjectPath ();
3602 _nameSpace n;
3603
3604 cop->setNameSpace (n.nameSpace ());
3605 cop->setHost (n.hostName ());
3606
3607 return cop;
3608 }
|
3609 mark.hamzy 1.20
|
3610 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1new
3611 (JNIEnv *jEnv, jobject jThs)
3612 {
3613 return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, construct ());
|
3614 schuur 1.1 }
3615
|
3616 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCn
3617 (JNIEnv *jEnv, jobject jThs, jstring jCn)
|
3618 mark.hamzy 1.20 {
|
3619 mark.hamzy 1.62 CIMObjectPath *cop = construct ();
3620 const char *str = jEnv->GetStringUTFChars (jCn, NULL);
3621
3622 if (str)
3623 cop->setClassName (str);
3624
3625 jEnv->ReleaseStringUTFChars (jCn, str);
|
3626 mark.hamzy 1.20
|
3627 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);
|
3628 schuur 1.1 }
3629
|
3630 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCnNs
3631 (JNIEnv *jEnv, jobject jThs, jstring jCn, jstring jNs)
|
3632 mark.hamzy 1.20 {
|
3633 mark.hamzy 1.62 CIMObjectPath *cop = construct ();
3634 const char *str1 = NULL;
3635 const char *str2 = NULL;
3636
3637 try {
3638 if (jCn)
3639 str1 = jEnv->GetStringUTFChars (jCn, NULL);
3640 if (jNs)
3641 str2 = jEnv->GetStringUTFChars (jNs, NULL);
3642 if (str1)
3643 cop->setClassName (str1);
3644 if (str2)
3645 cop->setNameSpace (str2);
3646 }
3647 Catch (jEnv);
3648
3649 if (str1)
3650 jEnv->ReleaseStringUTFChars (jCn, str1);
3651 if (str2)
3652 jEnv->ReleaseStringUTFChars (jNs, str2);
|
3653 mark.hamzy 1.20
|
3654 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);
3655 }
|
3656 mark.hamzy 1.20
|
3657 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCi
3658 (JNIEnv *jEnv, jobject jThs, jlong jInst)
3659 {
3660 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst);
3661 CIMObjectPath *cop = 0;
3662 _nameSpace n;
|
3663 mark.hamzy 1.20
|
3664 mark.hamzy 1.62 try
|
3665 mark.hamzy 1.56 {
|
3666 mark.hamzy 1.62 if (ci)
3667 {
3668 cop = new CIMObjectPath (ci->getPath ());
3669
3670 if (cop)
3671 {
3672 if (cop->getNameSpace ().isNull ())
3673 cop->setNameSpace (n.nameSpace ());
3674
3675 if (cop->getHost ().size () == 0)
3676 cop->setHost (n.hostName ());
3677 }
3678 }
3679 }
3680 Catch (jEnv);
3681
3682 return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);
3683 }
3684
3685 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCiNs
3686 (JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jNamespace)
3687 mark.hamzy 1.62 {
3688 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst);
3689 CIMObjectPath *cop = 0;
3690 const char *pszNamespace = jEnv->GetStringUTFChars (jNamespace, NULL);
3691 CIMNamespaceName cnnNamespace;
3692 bool fNamespaceValid = false;
3693 _nameSpace n;
3694
3695 try
|
3696 mark.hamzy 1.56 {
|
3697 mark.hamzy 1.62 cnnNamespace = pszNamespace;
3698 fNamespaceValid = true;
|
3699 mark.hamzy 1.56 }
|
3700 mark.hamzy 1.62 catch (Exception e)
|
3701 mark.hamzy 1.56 {
3702 }
|
3703 mark.hamzy 1.62
3704 jEnv->ReleaseStringUTFChars (jNamespace, pszNamespace);
3705
3706 try
|
3707 mark.hamzy 1.56 {
|
3708 mark.hamzy 1.62 if (ci)
3709 {
3710 cop = new CIMObjectPath (ci->getPath ());
3711
3712 if (cop)
3713 {
3714 if (fNamespaceValid)
3715 {
3716 cop->setNameSpace (cnnNamespace);
3717 }
3718 else
3719 {
3720 if (cop->getNameSpace ().isNull ())
3721 cop->setNameSpace (n.nameSpace ());
3722 }
3723
3724 if (cop->getHost ().size () == 0)
3725 cop->setHost (n.hostName ());
3726 }
3727 }
|
3728 mark.hamzy 1.56 }
|
3729 mark.hamzy 1.62 Catch (jEnv);
|
3730 mark.hamzy 1.56
|
3731 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);
|
3732 schuur 1.1 }
3733
|
3734 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1finalize
3735 (JNIEnv *jEnv, jobject jThs, jlong jCop)
|
3736 mark.hamzy 1.20 {
|
3737 mark.hamzy 1.62 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
3738
3739 delete cop;
|
3740 mark.hamzy 1.20
|
3741 mark.hamzy 1.62 DEBUG_ConvertCleanup (jlong, jCop);
|
3742 schuur 1.5 }
3743
|
3744 mark.hamzy 1.62 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getNameSpace
3745 (JNIEnv *jEnv, jobject jThs, jlong jCop)
|
3746 mark.hamzy 1.20 {
|
3747 mark.hamzy 1.62 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
3748 const String &ns = cop->getNameSpace ().getString ();
3749
3750 jstring str = jEnv->NewStringUTF (ns.getCString ());
|
3751 mark.hamzy 1.20
|
3752 schuur 1.1 return str;
3753 }
3754
|
3755 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setNameSpace
3756 (JNIEnv *jEnv, jobject jThs, jlong jCop, jstring jName)
3757 {
3758 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
3759 const char *str = jEnv->GetStringUTFChars (jName,NULL);
3760
3761 cop->setNameSpace (CIMNamespaceName (str));
3762
3763 jEnv->ReleaseStringUTFChars (jName,str);
3764 }
3765
3766 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getHost
3767 (JNIEnv *jEnv, jobject jThs, jlong jCop)
|
3768 mark.hamzy 1.20 {
|
3769 mark.hamzy 1.62 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
3770 const String &hn = cop->getHost ();
|
3771 mark.hamzy 1.20
|
3772 mark.hamzy 1.62 jstring str = jEnv->NewStringUTF (hn.getCString ());
|
3773 mark.hamzy 1.27
|
3774 mark.hamzy 1.62 return str;
|
3775 schuur 1.5 }
3776
|
3777 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setHost
3778 (JNIEnv *jEnv, jobject jThs, jlong jCop, jstring jName)
|
3779 mark.hamzy 1.20 {
|
3780 mark.hamzy 1.62 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
3781 const char *str = jEnv->GetStringUTFChars (jName,NULL);
3782
3783 cop->setHost (String (str));
|
3784 mark.hamzy 1.20
|
3785 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jName,str);
|
3786 schuur 1.1 }
3787
|
3788 mark.hamzy 1.62 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getObjectName
3789 (JNIEnv *jEnv, jobject jThs, jlong jCop)
|
3790 mark.hamzy 1.20 {
|
3791 mark.hamzy 1.62 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
3792 const String &cn = cop->getClassName ().getString ();
|
3793 mark.hamzy 1.20
|
3794 mark.hamzy 1.62 jstring str = jEnv->NewStringUTF (cn.getCString ());
|
3795 mark.hamzy 1.20
|
3796 schuur 1.1 return str;
3797 }
3798
|
3799 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setObjectName
3800 (JNIEnv *jEnv, jobject jThs, jlong jCop, jstring jName)
|
3801 mark.hamzy 1.20 {
|
3802 mark.hamzy 1.62 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
3803 const char *str = jEnv->GetStringUTFChars (jName,NULL);
|
3804 mark.hamzy 1.35
|
3805 mark.hamzy 1.62 cop->setClassName (String (str));
|
3806 mark.hamzy 1.35
|
3807 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jName,str);
|
3808 schuur 1.1 }
3809
|
3810 mark.hamzy 1.62 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeys
3811 (JNIEnv *jEnv, jobject jThs, jlong jCop, jobject jVec)
|
3812 mark.hamzy 1.20 {
|
3813 mark.hamzy 1.62 JMPIjvm::cacheIDs (jEnv);
|
3814 mark.hamzy 1.20
|
3815 mark.hamzy 1.62 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
3816 const Array<CIMKeyBinding> &akb = cop->getKeyBindings ();
|
3817 mark.hamzy 1.20
|
3818 mark.hamzy 1.62 for (Uint32 i = 0, s = akb.size (); i < s; i++)
|
3819 mark.hamzy 1.35 {
|
3820 mark.hamzy 1.62 const String &n = akb[i].getName ().getString ();
3821 const String &v = akb[i].getValue ();
3822 CIMKeyBinding::Type t = akb[i].getType ();
3823 CIMValue *cv = 0;
3824
3825 switch (t)
3826 {
3827 case CIMKeyBinding::NUMERIC:
3828 cv = new CIMValue ((Sint32)atol (v.getCString ()));
3829 break;
3830 case CIMKeyBinding::STRING:
3831 cv = new CIMValue (v);
3832 break;
3833 case CIMKeyBinding::BOOLEAN:
3834 cv = new CIMValue ((Boolean) (v.getCString ()));
3835 break;
3836 case CIMKeyBinding::REFERENCE:
3837 cv = new CIMValue (CIMObjectPath (akb[i].getValue ()));
3838 break;
3839 default:
3840 throwCIMException (jEnv,"+++ unsupported type: ");
3841 mark.hamzy 1.62 }
|
3842 mark.hamzy 1.20
|
3843 mark.hamzy 1.62 CIMProperty *cp = 0;
|
3844 mark.hamzy 1.35
|
3845 mark.hamzy 1.62 if (t != CIMKeyBinding::REFERENCE)
3846 cp = new CIMProperty (n, *cv);
3847 else
3848 cp = new CIMProperty (n, *cv, 0, ((CIMObjectPath) akb[i].getValue ()).getClassName ());
|
3849 mark.hamzy 1.20
|
3850 mark.hamzy 1.62 jlong jCp = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp);
3851 jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewJ,jCp);
|
3852 mark.hamzy 1.41
|
3853 mark.hamzy 1.62 jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,prop);
|
3854 mark.hamzy 1.35 }
|
3855 mark.hamzy 1.62
3856 return jVec;
|
3857 schuur 1.5 }
3858
|
3859 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setKeys
3860 (JNIEnv *jEnv, jobject jThs, jlong jCop, jobject jVec)
|
3861 mark.hamzy 1.20 {
|
3862 mark.hamzy 1.62 JMPIjvm::cacheIDs (jEnv);
|
3863 mark.hamzy 1.20
|
3864 mark.hamzy 1.62 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
3865 Array<CIMKeyBinding> akb;
|
3866 schuur 1.1
|
3867 mark.hamzy 1.62 for (Uint32 i = 0, s = jEnv->CallIntMethod (jVec,JMPIjvm::jv.VectorSize); i < s; i++)
3868 {
3869 jobject o = jEnv->CallObjectMethod (jVec,JMPIjvm::jv.VectorElementAt, (i));
3870 jlong jCp = jEnv->CallLongMethod (o,JMPIjvm::jv.CIMPropertyCInst);
3871 CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jCp);
|
3872 mark.hamzy 1.20
|
3873 mark.hamzy 1.62 akb.append (CIMKeyBinding (cp->getName (), cp->getValue ()));
3874 }
|
3875 mark.hamzy 1.20
|
3876 mark.hamzy 1.62 cop->setKeyBindings (akb);
|
3877 schuur 1.1 }
|
3878 schuur 1.5
|
3879 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1addKey
3880 (JNIEnv *jEnv, jobject jThs, jlong jCop, jstring jId, jlong jVal)
|
3881 mark.hamzy 1.39 {
|
3882 mark.hamzy 1.62 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
3883 const char *str = jEnv->GetStringUTFChars (jId, NULL);
3884 CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jVal);
3885 Array<CIMKeyBinding> keyBindings = cop->getKeyBindings ();
|
3886 mark.hamzy 1.39
|
3887 mark.hamzy 1.62 keyBindings.append (CIMKeyBinding (str,*cv));
3888 cop->setKeyBindings (Array<CIMKeyBinding> (keyBindings));
|
3889 mark.hamzy 1.39
|
3890 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jId, str);
|
3891 mark.hamzy 1.39 }
3892
|
3893 mark.hamzy 1.62 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeyValue
3894 (JNIEnv *jEnv, jobject jThs, jlong jCop, jstring jStr)
|
3895 mark.hamzy 1.39 {
|
3896 mark.hamzy 1.62 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
3897 const Array<CIMKeyBinding> &akb = cop->getKeyBindings ();
3898 const char *strKeyName = jEnv->GetStringUTFChars (jStr,NULL);
3899 jstring retStr = NULL;
|
3900 mark.hamzy 1.39
|
3901 mark.hamzy 1.62 for (Uint32 i = 0,s = akb.size (); i<s; i++)
|
3902 mark.hamzy 1.39 {
|
3903 mark.hamzy 1.62 const String &n = akb[i].getName ().getString ();
3904
3905 if (n == String (strKeyName))
3906 {
3907 retStr = jEnv->NewStringUTF (akb[i].getValue ().getCString ());
3908 break;
3909 }
|
3910 mark.hamzy 1.39 }
3911
|
3912 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jStr,strKeyName);
|
3913 mark.hamzy 1.39
|
3914 mark.hamzy 1.62 return retStr;
|
3915 schuur 1.5 }
3916
|
3917 mark.hamzy 1.62 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1toString
3918 (JNIEnv *jEnv, jobject jThs, jlong jCop)
|
3919 mark.hamzy 1.20 {
|
3920 mark.hamzy 1.62 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
3921 const String &ns = cop->toString ();
|
3922 mark.hamzy 1.20
|
3923 mark.hamzy 1.62 jstring str = jEnv->NewStringUTF (ns.getCString ());
|
3924 mark.hamzy 1.20
|
3925 mark.hamzy 1.62 return str;
|
3926 schuur 1.5 }
3927
|
3928 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1clone
3929 (JNIEnv *jEnv, jobject jThs, jlong jCop)
|
3930 mark.hamzy 1.20 {
|
3931 mark.hamzy 1.62 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
3932 CIMObjectPath *copl = new CIMObjectPath (cop->getHost (), cop->getNameSpace (), cop->getClassName (), cop->getKeyBindings ());
|
3933 mark.hamzy 1.20
|
3934 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, copl);
|
3935 schuur 1.5 }
3936
|
3937 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1set
3938 (JNIEnv *jEnv, jobject jThs, jstring jStr)
|
3939 mark.hamzy 1.20 {
|
3940 mark.hamzy 1.62 const char *strCop = jEnv->GetStringUTFChars (jStr,NULL);
3941 CIMObjectPath *cop = new CIMObjectPath ();
|
3942 mark.hamzy 1.20
|
3943 mark.hamzy 1.62 cop->set (String (strCop));
|
3944 mark.hamzy 1.24
|
3945 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jStr,strCop);
|
3946 mark.hamzy 1.24
|
3947 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);
|
3948 schuur 1.5 }
3949
3950
|
3951 schuur 1.1 // -------------------------------------
3952 // ---
|
3953 mark.hamzy 1.62 // - CIMOMHandle
|
3954 schuur 1.1 // ---
3955 // -------------------------------------
3956
|
3957 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getClass
3958 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jboolean lo,
3959 jboolean iq, jboolean ic, jobjectArray jPl)
|
3960 mark.hamzy 1.20 {
|
3961 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
3962 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
3963 CIMPropertyList pl;
3964 OperationContext ctx;
|
3965 mark.hamzy 1.20
|
3966 mark.hamzy 1.62 if (jPl)
3967 pl = getList (jEnv, jPl);
3968 else
3969 pl = CIMPropertyList ();
|
3970 mark.hamzy 1.20
|
3971 mark.hamzy 1.62 try {
3972 CIMClass cls = ch->getClass (ctx,
3973 cop->getNameSpace (),
3974 cop->getClassName (),
3975 (Boolean)lo,
3976 (Boolean)iq,
3977 (Boolean)ic,
3978 pl);
|
3979 schuur 1.5
|
3980 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMClass*, jlong, new CIMClass (cls));
3981 }
3982 Catch(jEnv);
|
3983 mark.hamzy 1.20
|
3984 mark.hamzy 1.62 return 0;
|
3985 schuur 1.1 }
3986
|
3987 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteClass
3988 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop)
|
3989 mark.hamzy 1.20 {
|
3990 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
3991 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
3992 OperationContext ctx;
3993
3994 try {
3995 ch->deleteClass (ctx,
3996 cop->getNameSpace (),
3997 cop->getClassName ());
3998 }
3999 Catch(jEnv);
|
4000 schuur 1.5 }
4001
|
4002 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createClass
4003 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jlong jCl)
|
4004 mark.hamzy 1.20 {
|
4005 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4006 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4007 CIMClass *cl = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCl);
4008 OperationContext ctx;
|
4009 mark.hamzy 1.20
|
4010 mark.hamzy 1.62 try {
4011 ch->createClass (ctx,
4012 cop->getNameSpace (),
4013 *cl);
4014 }
4015 Catch(jEnv);
|
4016 schuur 1.5 }
4017
|
4018 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setClass
4019 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jlong jCl)
|
4020 mark.hamzy 1.20 {
|
4021 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4022 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4023 CIMClass *cl = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCl);
4024 OperationContext ctx;
|
4025 mark.hamzy 1.20
|
4026 mark.hamzy 1.62 try {
4027 ch->modifyClass (ctx,
4028 cop->getNameSpace (),
4029 *cl);
4030 }
4031 Catch(jEnv);
|
4032 schuur 1.5 }
4033
|
4034 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClassNames
4035 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jboolean deep)
|
4036 mark.hamzy 1.20 {
|
4037 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4038 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4039 CIMNamespaceName ns = cop->getNameSpace ();
4040 OperationContext ctx;
|
4041 mark.hamzy 1.51
|
4042 mark.hamzy 1.62 try {
4043 Array<CIMName> enm = ch->enumerateClassNames (ctx,
4044 cop->getNameSpace (),
4045 cop->getClassName (),
4046 (Boolean)deep);
4047 Array<CIMObjectPath> *enmop = new Array<CIMObjectPath> ();
|
4048 mark.hamzy 1.20
|
4049 mark.hamzy 1.62 for (int i = 0, m = enm.size (); i < m; i++)
4050 {
4051 enmop->append (CIMObjectPath (String::EMPTY,
4052 ns,
4053 enm[i]));
4054 }
|
4055 mark.hamzy 1.27
|
4056 mark.hamzy 1.62 return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jlong, enmop);
|
4057 mark.hamzy 1.51 }
|
4058 mark.hamzy 1.62 Catch(jEnv);
|
4059 mark.hamzy 1.20
|
4060 mark.hamzy 1.62 return 0;
|
4061 schuur 1.1 }
4062
|
4063 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClasses
4064 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jboolean deep,
4065 jboolean lo, jboolean iq, jboolean ic)
|
4066 mark.hamzy 1.20 {
|
4067 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4068 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4069 OperationContext ctx;
|
4070 mark.hamzy 1.20
|
4071 mark.hamzy 1.62 try {
4072 Array<CIMClass> en = ch->enumerateClasses (ctx,
4073 cop->getNameSpace (),
4074 cop->getClassName (),
4075 (Boolean)deep,
4076 (Boolean)lo,
4077 (Boolean)iq,
4078 (Boolean)ic);
|
4079 schuur 1.1
|
4080 mark.hamzy 1.62 return DEBUG_ConvertCToJava (Array<CIMClass>*, jlong, new Array<CIMClass> (en));
|
4081 mark.hamzy 1.51 }
|
4082 mark.hamzy 1.62 Catch (jEnv);
|
4083 mark.hamzy 1.51
|
4084 mark.hamzy 1.62 return 0;
|
4085 mark.hamzy 1.51 }
4086
|
4087 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getInstance
4088 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jboolean lo, jboolean iq, jboolean ic,
4089 jobjectArray jPl)
|
4090 mark.hamzy 1.51 {
|
4091 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4092 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4093 OperationContext ctx;
4094 CIMPropertyList pl;
4095
4096 if (jPl)
4097 pl = getList (jEnv,jPl);
4098 else
4099 pl = CIMPropertyList ();
4100
4101 try {
4102 CIMInstance *inst = new CIMInstance (ch->getInstance (ctx,
4103 cop->getNameSpace (),
4104 *cop,
4105 (Boolean)lo,
4106 (Boolean)iq,
4107 (Boolean)ic,
4108 pl));
|
4109 mark.hamzy 1.51
|
4110 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMInstance*, jlong, inst);
|
4111 mark.hamzy 1.51 }
|
4112 mark.hamzy 1.62 Catch (jEnv);
|
4113 mark.hamzy 1.20
|
4114 mark.hamzy 1.62 return 0;
|
4115 schuur 1.1 }
4116
|
4117 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance
4118 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop)
|
4119 mark.hamzy 1.20 {
|
4120 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4121 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4122 OperationContext ctx;
|
4123 mark.hamzy 1.20
|
4124 mark.hamzy 1.62 try {
4125 ch->deleteInstance (ctx,cop->getNameSpace (),*cop);
4126 }
4127 Catch (jEnv);
|
4128 schuur 1.1 }
4129
|
4130 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createInstance
4131 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jlong jCi)
4132 {
4133 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4134 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4135 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jCi);
4136 OperationContext ctx;
|
4137 schuur 1.1
|
4138 mark.hamzy 1.62 try {
4139 ci->setPath (*cop);
|
4140 mark.hamzy 1.53
|
4141 mark.hamzy 1.62 CIMObjectPath obj = ch->createInstance (ctx,
4142 cop->getNameSpace (),
4143 *ci);
|
4144 mark.hamzy 1.53
|
4145 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, new CIMObjectPath (obj));
|
4146 mark.hamzy 1.53 }
|
4147 mark.hamzy 1.62 Catch (jEnv);
|
4148 mark.hamzy 1.20
|
4149 mark.hamzy 1.62 return 0;
|
4150 schuur 1.1 }
4151
|
4152 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1modifyInstance
4153 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jlong jCi,
4154 jboolean iq, jobjectArray jPl)
|
4155 mark.hamzy 1.20 {
|
4156 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4157 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4158 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jCi);
4159 CIMPropertyList pl = getList (jEnv, jPl);
4160 OperationContext ctx;
|
4161 mark.hamzy 1.20
|
4162 mark.hamzy 1.62 try {
4163 ci->setPath (*cop);
4164 ch->modifyInstance (ctx,
4165 cop->getNameSpace (),
4166 *ci,
4167 (Boolean)iq,
4168 pl);
4169 }
4170 Catch (jEnv);
|
4171 schuur 1.1 }
4172
|
4173 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstanceNames
4174 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jboolean deep)
|
4175 mark.hamzy 1.20 {
|
4176 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4177 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4178 OperationContext ctx;
|
4179 mark.hamzy 1.20
|
4180 mark.hamzy 1.62 try {
4181 Array<CIMObjectPath> enm = ch->enumerateInstanceNames (ctx,
4182 cop->getNameSpace (),
4183 cop->getClassName ()); //, (Boolean)deep);
4184 return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jlong, new Array<CIMObjectPath> (enm));
4185 }
4186 Catch (jEnv);
|
4187 mark.hamzy 1.20
|
4188 mark.hamzy 1.62 return 0;
|
4189 schuur 1.1 }
4190
|
4191 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstances
4192 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jboolean deep,
4193 jboolean lo, jboolean iq, jboolean ic, jobjectArray jPl)
|
4194 mark.hamzy 1.20 {
|
4195 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4196 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4197 CIMPropertyList pl;
4198 OperationContext ctx;
|
4199 mark.hamzy 1.20
|
4200 mark.hamzy 1.62 if (jPl)
4201 pl = getList (jEnv, jPl);
|
4202 mark.hamzy 1.20 else
|
4203 mark.hamzy 1.62 pl = CIMPropertyList ();
|
4204 mark.hamzy 1.20
|
4205 mark.hamzy 1.62 try {
4206 Array<CIMInstance> en = ch->enumerateInstances (ctx,
4207 cop->getNameSpace (),
4208 cop->getClassName (),
4209 (Boolean)deep,
4210 (Boolean)lo,
4211 (Boolean)iq,
4212 (Boolean)ic,
4213 pl);
|
4214 schuur 1.1
|
4215 mark.hamzy 1.62 return DEBUG_ConvertCToJava (Array<CIMInstance>*, jlong, new Array<CIMInstance> (en));
4216 }
4217 Catch (jEnv);
|
4218 mark.hamzy 1.20
|
4219 mark.hamzy 1.62 return 0;
|
4220 schuur 1.1 }
4221
|
4222 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1execQuery
4223 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jstring jQuery, jstring jQl)
|
4224 mark.hamzy 1.20 {
|
4225 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4226 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4227 OperationContext ctx;
4228 const char *str = jEnv->GetStringUTFChars (jQuery,NULL);
4229 String query (str);
|
4230 mark.hamzy 1.20
|
4231 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jQuery,str);
|
4232 mark.hamzy 1.20
|
4233 mark.hamzy 1.62 str = jEnv->GetStringUTFChars (jQl, NULL);
|
4234 schuur 1.1
|
4235 mark.hamzy 1.62 String ql (str);
|
4236 mark.hamzy 1.20
|
4237 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jQl, str);
|
4238 schuur 1.1
|
4239 mark.hamzy 1.62 try {
4240 Array<CIMObject> enm = ch->execQuery (ctx,
4241 cop->getNameSpace (),
4242 ql,
4243 query);
4244 Array<CIMInstance> *enmInst = new Array<CIMInstance> ();
|
4245 mark.hamzy 1.20
|
4246 mark.hamzy 1.62 for (int i = 0,m = enm.size (); i<m; i++)
4247 {
4248 enmInst->append (CIMInstance (enm[i]));
4249 }
|
4250 schuur 1.1
|
4251 mark.hamzy 1.62 return DEBUG_ConvertCToJava (Array<CIMInstance>*, jlong, enmInst);
4252 }
4253 Catch (jEnv);
|
4254 mark.hamzy 1.20
|
4255 mark.hamzy 1.62 return 0;
|
4256 schuur 1.1 }
4257
|
4258 mark.hamzy 1.20
|
4259 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getProperty
4260 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jstring jN)
|
4261 mark.hamzy 1.20 {
|
4262 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4263 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4264 OperationContext ctx;
4265 const char *str = jEnv->GetStringUTFChars (jN, NULL);
4266 CIMName prop (str);
|
4267 mark.hamzy 1.20
|
4268 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jN, str);
|
4269 schuur 1.1
|
4270 mark.hamzy 1.62 try {
4271 CIMValue *cv = new CIMValue (ch->getProperty (ctx,
4272 cop->getNameSpace (),
4273 *cop,
4274 prop));
|
4275 mark.hamzy 1.35
|
4276 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
4277 }
4278 Catch (jEnv);
|
4279 mark.hamzy 1.35
|
4280 mark.hamzy 1.62 return 0;
|
4281 mark.hamzy 1.35 }
4282
|
4283 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setProperty
4284 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jstring jPn, jlong jV)
|
4285 mark.hamzy 1.20 {
|
4286 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4287 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4288 OperationContext ctx;
4289 CIMValue *val = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);
4290 const char *str = jEnv->GetStringUTFChars (jPn, NULL);
4291 CIMName pName (str);
|
4292 mark.hamzy 1.20
|
4293 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jPn, str);
|
4294 schuur 1.1
|
4295 mark.hamzy 1.62 try {
4296 ch->setProperty (ctx,
4297 cop->getNameSpace (),
4298 *cop,
4299 pName,
4300 *val);
4301 }
4302 Catch (jEnv);
|
4303 schuur 1.1 }
4304
|
4305 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associatorNames
4306 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop,
4307 jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole)
|
4308 mark.hamzy 1.20 {
|
4309 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4310 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4311 OperationContext ctx;
4312 const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL);
|
4313 mark.hamzy 1.20
|
4314 mark.hamzy 1.62 CIMName assocClass;
|
4315 mark.hamzy 1.56
|
4316 mark.hamzy 1.62 if ( str
4317 && *str
4318 )
|
4319 mark.hamzy 1.44 {
|
4320 mark.hamzy 1.62 if (CIMName::legal (str))
4321 {
4322 assocClass = str;
4323 }
4324 else
4325 {
4326 jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
4327 JMPIjvm::jv.CIMExceptionNewISt,
4328 (jint)4, // CIM_ERR_INVALID_PARAMETER
4329 jEnv->NewStringUTF ("Invalid association class name"));
|
4330 mark.hamzy 1.56
|
4331 mark.hamzy 1.62 jEnv->Throw ((jthrowable)ev);
|
4332 mark.hamzy 1.56
|
4333 mark.hamzy 1.62 return 0;
4334 }
|
4335 schuur 1.1 }
|
4336 mark.hamzy 1.20
|
4337 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jAssocClass, str);
|
4338 mark.hamzy 1.35
|
4339 mark.hamzy 1.62 str = jEnv->GetStringUTFChars (jResultClass, NULL);
|
4340 schuur 1.1
|
4341 mark.hamzy 1.62 CIMName resultClass;
|
4342 mark.hamzy 1.20
|
4343 mark.hamzy 1.62 if ( str
4344 && *str
4345 )
|
4346 mark.hamzy 1.44 {
|
4347 mark.hamzy 1.62 if (CIMName::legal (str))
4348 {
4349 resultClass = str;
4350 }
4351 else
4352 {
4353 jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
4354 JMPIjvm::jv.CIMExceptionNewISt,
4355 (jint)4, // CIM_ERR_INVALID_PARAMETER
4356 jEnv->NewStringUTF ("Invalid result class name"));
|
4357 mark.hamzy 1.56
|
4358 mark.hamzy 1.62 jEnv->Throw ((jthrowable)ev);
|
4359 mark.hamzy 1.56
|
4360 mark.hamzy 1.62 return 0;
4361 }
|
4362 schuur 1.1 }
|
4363 mark.hamzy 1.56
|
4364 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jResultClass, str);
4365
4366 str = jEnv->GetStringUTFChars (jRole, NULL);
|
4367 mark.hamzy 1.56
|
4368 mark.hamzy 1.62 String role (str);
|
4369 mark.hamzy 1.20
|
4370 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jRole, str);
|
4371 mark.hamzy 1.35
|
4372 mark.hamzy 1.62 str = jEnv->GetStringUTFChars (jResultRole, NULL);
|
4373 schuur 1.1
|
4374 mark.hamzy 1.62 String resultRole (str);
|
4375 mark.hamzy 1.20
|
4376 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jResultRole, str);
|
4377 mark.hamzy 1.56
|
4378 mark.hamzy 1.62 try {
4379 Array<CIMObjectPath> enm = ch->associatorNames (ctx,
4380 cop->getNameSpace (),
4381 *cop,
4382 assocClass,
4383 resultClass,
4384 role,
4385 resultRole);
|
4386 mark.hamzy 1.56
|
4387 mark.hamzy 1.62 return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jlong, new Array<CIMObjectPath> (enm));
|
4388 schuur 1.1 }
|
4389 mark.hamzy 1.62 Catch (jEnv);
|
4390 mark.hamzy 1.56
|
4391 mark.hamzy 1.62 return 0;
|
4392 schuur 1.1 }
4393
|
4394 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associators
4395 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop,
4396 jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole,
4397 jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)
|
4398 mark.hamzy 1.20 {
|
4399 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4400 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4401 OperationContext ctx;
4402 CIMPropertyList pl = getList (jEnv, jPl);
4403 const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL);
4404 CIMName assocClass;
|
4405 mark.hamzy 1.20
|
4406 mark.hamzy 1.62 if ( str
4407 && *str
4408 )
|
4409 mark.hamzy 1.44 {
|
4410 mark.hamzy 1.62 if (CIMName::legal (str))
4411 {
4412 assocClass = str;
4413 }
4414 else
4415 {
4416 jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
4417 JMPIjvm::jv.CIMExceptionNewISt,
4418 (jint)4, // CIM_ERR_INVALID_PARAMETER
4419 jEnv->NewStringUTF ("Invalid association class name"));
|
4420 mark.hamzy 1.56
|
4421 mark.hamzy 1.62 jEnv->Throw ((jthrowable)ev);
|
4422 mark.hamzy 1.56
|
4423 mark.hamzy 1.62 return 0;
4424 }
|
4425 schuur 1.1 }
|
4426 mark.hamzy 1.56
|
4427 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jAssocClass, str);
|
4428 mark.hamzy 1.56
|
4429 mark.hamzy 1.62 str = jEnv->GetStringUTFChars (jResultClass, NULL);
|
4430 mark.hamzy 1.20
|
4431 mark.hamzy 1.62 CIMName resultClass;
|
4432 mark.hamzy 1.35
|
4433 mark.hamzy 1.62 if ( str
4434 && *str
4435 )
|
4436 mark.hamzy 1.44 {
|
4437 mark.hamzy 1.62 if (CIMName::legal (str))
4438 {
4439 resultClass = str;
4440 }
4441 else
4442 {
4443 jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
4444 JMPIjvm::jv.CIMExceptionNewISt,
4445 (jint)4, // CIM_ERR_INVALID_PARAMETER
4446 jEnv->NewStringUTF ("Invalid result class name"));
|
4447 mark.hamzy 1.27
|
4448 mark.hamzy 1.62 jEnv->Throw ((jthrowable)ev);
|
4449 mark.hamzy 1.27
|
4450 mark.hamzy 1.62 return 0;
4451 }
|
4452 schuur 1.1 }
4453
|
4454 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jResultClass, str);
|
4455 mark.hamzy 1.20
|
4456 mark.hamzy 1.62 str = jEnv->GetStringUTFChars (jRole, NULL);
|
4457 schuur 1.1
|
4458 mark.hamzy 1.62 String role (str);
|
4459 mark.hamzy 1.20
|
4460 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jRole, str);
|
4461 mark.hamzy 1.56
|
4462 mark.hamzy 1.62 str = jEnv->GetStringUTFChars (jResultRole, NULL);
|
4463 mark.hamzy 1.20
|
4464 mark.hamzy 1.62 String resultRole (str);
|
4465 mark.hamzy 1.35
|
4466 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jResultRole, str);
|
4467 mark.hamzy 1.35
|
4468 mark.hamzy 1.62 try {
4469 Array<CIMObject> enm = ch->associators (ctx,
4470 cop->getNameSpace (),
4471 *cop,
4472 assocClass,
4473 resultClass,
4474 role,
4475 resultRole,
4476 (Boolean)includeQualifiers,
4477 (Boolean)includeClassOrigin,
4478 pl);
4479 Array<CIMInstance> *enmInst = new Array<CIMInstance> ();
|
4480 mark.hamzy 1.35
|
4481 mark.hamzy 1.62 for (int i = 0, m = enm.size (); i < m; i++)
4482 {
4483 enmInst->append (CIMInstance (enm[i]));
4484 }
|
4485 mark.hamzy 1.56
|
4486 mark.hamzy 1.62 return DEBUG_ConvertCToJava (Array<CIMInstance>*, jlong, enmInst);
4487 }
4488 Catch (jEnv);
|
4489 mark.hamzy 1.35
|
4490 mark.hamzy 1.62 return 0;
|
4491 mark.hamzy 1.35 }
4492
|
4493 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1referenceNames
4494 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop,
4495 jstring jAssocClass, jstring jRole)
|
4496 mark.hamzy 1.35 {
|
4497 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4498 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4499 OperationContext ctx;
4500 const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL);
4501 CIMName assocClass;
4502
4503 if ( str
4504 && *str
4505 )
4506 {
4507 if (CIMName::legal (str))
4508 {
4509 assocClass = str;
4510 }
4511 else
4512 {
4513 jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
4514 JMPIjvm::jv.CIMExceptionNewISt,
4515 (jint)4, // CIM_ERR_INVALID_PARAMETER
4516 jEnv->NewStringUTF ("Invalid association class name"));
|
4517 mark.hamzy 1.35
|
4518 mark.hamzy 1.62 jEnv->Throw ((jthrowable)ev);
|
4519 mark.hamzy 1.56
|
4520 mark.hamzy 1.62 return 0;
4521 }
4522 }
|
4523 mark.hamzy 1.35
|
4524 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jAssocClass, str);
|
4525 mark.hamzy 1.35
|
4526 mark.hamzy 1.62 str = jEnv->GetStringUTFChars (jRole, NULL);
|
4527 schuur 1.1
|
4528 mark.hamzy 1.62 String role (str);
|
4529 mark.hamzy 1.20
|
4530 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jRole, str);
|
4531 mark.hamzy 1.56
|
4532 mark.hamzy 1.62 try {
4533 Array<CIMObjectPath> enm = ch->referenceNames (ctx,
4534 cop->getNameSpace (),
4535 *cop,
4536 assocClass,
4537 role);
|
4538 mark.hamzy 1.20
|
4539 mark.hamzy 1.62 return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jlong, new Array<CIMObjectPath> (enm));
4540 }
4541 Catch (jEnv);
|
4542 mark.hamzy 1.35
|
4543 mark.hamzy 1.62 return 0;
|
4544 mark.hamzy 1.35 }
4545
|
4546 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1references
4547 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop,
4548 jstring jAssocClass, jstring jRole,
4549 jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)
|
4550 mark.hamzy 1.35 {
|
4551 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4552 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4553 OperationContext ctx;
4554 CIMPropertyList pl = getList (jEnv, jPl);
4555 const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL);
4556 CIMName assocClass;
|
4557 mark.hamzy 1.35
|
4558 mark.hamzy 1.62 if ( str
4559 && *str
4560 )
|
4561 mark.hamzy 1.61 {
|
4562 mark.hamzy 1.62 if (CIMName::legal (str))
4563 {
4564 assocClass = str;
4565 }
4566 else
4567 {
4568 jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
4569 JMPIjvm::jv.CIMExceptionNewISt,
4570 (jint)4, // CIM_ERR_INVALID_PARAMETER
4571 jEnv->NewStringUTF ("Invalid association class name"));
4572
4573 jEnv->Throw ((jthrowable)ev);
4574
4575 return 0;
4576 }
|
4577 mark.hamzy 1.61 }
|
4578 mark.hamzy 1.56
|
4579 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jAssocClass, str);
|
4580 mark.hamzy 1.35
|
4581 mark.hamzy 1.62 str = jEnv->GetStringUTFChars (jRole, NULL);
|
4582 mark.hamzy 1.35
|
4583 mark.hamzy 1.62 String role (str);
|
4584 mark.hamzy 1.35
|
4585 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jRole, str);
|
4586 mark.hamzy 1.35
|
4587 mark.hamzy 1.62 try {
4588 Array<CIMObject> enm = ch->references (ctx,
4589 cop->getNameSpace (),
4590 *cop,
4591 assocClass,
4592 role,
4593 (Boolean)includeQualifiers,
4594 (Boolean)includeClassOrigin,
4595 pl);
4596 Array<CIMInstance> *enmInst = new Array<CIMInstance> ();
|
4597 mark.hamzy 1.56
|
4598 mark.hamzy 1.62 for (int i = 0, m = enm.size (); i < m; i++)
4599 {
4600 enmInst->append (CIMInstance (enm[i]));
4601 }
|
4602 mark.hamzy 1.35
|
4603 mark.hamzy 1.62 return DEBUG_ConvertCToJava (Array<CIMInstance>*, jlong, enmInst);
4604 }
4605 Catch (jEnv);
|
4606 mark.hamzy 1.35
|
4607 mark.hamzy 1.62 return 0;
|
4608 mark.hamzy 1.35 }
4609
|
4610 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod
4611 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jstring jMn, jobject jIn, jobject jOut)
|
4612 mark.hamzy 1.35 {
|
4613 mark.hamzy 1.62 JMPIjvm::cacheIDs (jEnv);
4614
4615 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4616 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4617 OperationContext ctx;
4618 const char *str = jEnv->GetStringUTFChars (jMn,NULL);
4619 CIMName method (str);
4620
4621 jEnv->ReleaseStringUTFChars (jMn,str);
4622
4623 Array<CIMParamValue> in;
4624 Array<CIMParamValue> out;
|
4625 mark.hamzy 1.35
|
4626 mark.hamzy 1.62 for (int i = 0, m = jEnv->CallIntMethod (jIn,JMPIjvm::jv.VectorSize); i < m; i++)
4627 {
4628 JMPIjvm::checkException (jEnv);
|
4629 mark.hamzy 1.56
|
4630 mark.hamzy 1.62 jobject jProp = jEnv->CallObjectMethod (jIn,JMPIjvm::jv.VectorElementAt,i);
|
4631 mark.hamzy 1.35
|
4632 mark.hamzy 1.62 JMPIjvm::checkException (jEnv);
|
4633 mark.hamzy 1.35
|
4634 mark.hamzy 1.62 jlong jp = jEnv->CallLongMethod (jProp,JMPIjvm::jv.CIMPropertyCInst);
4635 CIMProperty *p = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jp);
|
4636 schuur 1.1
|
4637 mark.hamzy 1.62 JMPIjvm::checkException (jEnv);
|
4638 mark.hamzy 1.35
|
4639 mark.hamzy 1.62 in.append (CIMParamValue (p->getName ().getString (),p->getValue ()));
4640 }
4641 try {
4642 CIMValue *val = new CIMValue (ch->invokeMethod (ctx,
4643 cop->getNameSpace (),
4644 *cop,
4645 method,
4646 in,
4647 out));
|
4648 mark.hamzy 1.20
|
4649 mark.hamzy 1.62 for (int i = 0,m = out.size (); i<m; i++)
4650 {
4651 const CIMParamValue &parm = out[i];
4652 const CIMValue v = parm.getValue ();
4653 CIMProperty *p = new CIMProperty (parm.getParameterName (),
4654 v,
4655 v.getArraySize ());
4656 jlong jp = DEBUG_ConvertCToJava (CIMProperty*, jlong, p);
4657 jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,
4658 JMPIjvm::jv.CIMPropertyNewJ,
4659 jp);
|
4660 schuur 1.1
|
4661 mark.hamzy 1.62 jEnv->CallVoidMethod (jOut, JMPIjvm::jv.VectorAddElement, prop);
4662 }
4663 return DEBUG_ConvertCToJava (CIMValue*, jlong, val);
4664 }
4665 Catch (jEnv);
|
4666 mark.hamzy 1.20
|
4667 mark.hamzy 1.62 return 0;
|
4668 schuur 1.1 }
4669
|
4670 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod24
4671 (JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jstring jMn,
4672 jobjectArray jIn, jobjectArray jOut)
4673
|
4674 mark.hamzy 1.20 {
|
4675 mark.hamzy 1.44 JMPIjvm::cacheIDs (jEnv);
|
4676 mark.hamzy 1.30
|
4677 mark.hamzy 1.62 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4678 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
4679 OperationContext ctx;
4680 const char *str = jEnv->GetStringUTFChars (jMn, NULL);
4681 CIMName method (str);
|
4682 mark.hamzy 1.20
|
4683 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jMn, str);
|
4684 mark.hamzy 1.20
|
4685 mark.hamzy 1.62 Array<CIMParamValue> in;
4686 Array<CIMParamValue> out;
|
4687 schuur 1.1
|
4688 mark.hamzy 1.62 if (jIn)
|
4689 mark.hamzy 1.35 {
|
4690 mark.hamzy 1.62 for (int i = 0, m = jEnv->GetArrayLength (jIn); i < m; i++)
|
4691 mark.hamzy 1.35 {
|
4692 mark.hamzy 1.62 JMPIjvm::checkException (jEnv);
|
4693 mark.hamzy 1.56
|
4694 mark.hamzy 1.62 jobject jArg = jEnv->GetObjectArrayElement (jIn,i);
|
4695 mark.hamzy 1.56
|
4696 mark.hamzy 1.62 JMPIjvm::checkException (jEnv);
|
4697 mark.hamzy 1.56
|
4698 mark.hamzy 1.62 jlong jp = jEnv->CallLongMethod (jArg,JMPIjvm::jv.CIMArgumentCInst);
4699 CIMParamValue *p = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jp);
|
4700 mark.hamzy 1.56
|
4701 mark.hamzy 1.62 JMPIjvm::checkException (jEnv);
|
4702 mark.hamzy 1.56
|
4703 mark.hamzy 1.62 in.append (*p);
|
4704 mark.hamzy 1.35 }
|
4705 mark.hamzy 1.62 }
4706 try {
4707 CIMValue *val = new CIMValue (ch->invokeMethod (ctx,
4708 cop->getNameSpace (),
4709 *cop,
4710 method,
4711 in,
4712 out));
4713
4714 if (jOut)
|
4715 mark.hamzy 1.56 {
|
4716 mark.hamzy 1.62 for (int i = 0, m = out.size (), o = jEnv->GetArrayLength (jOut); i < m && i< o; i++)
|
4717 mark.hamzy 1.35 {
|
4718 mark.hamzy 1.62 CIMParamValue *parm = new CIMParamValue (out[i]);
4719 jlong jParm = DEBUG_ConvertCToJava (CIMParamValue*, jlong, parm);
|
4720 mark.hamzy 1.35
|
4721 mark.hamzy 1.62 jEnv->SetObjectArrayElement (jOut,i,
4722 jEnv->NewObject (JMPIjvm::jv.CIMArgumentClassRef,JMPIjvm::jv.CIMArgumentNewJ,jParm));
|
4723 schuur 1.1 }
|
4724 mark.hamzy 1.35 }
|
4725 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, val);
|
4726 schuur 1.1 }
|
4727 mark.hamzy 1.62 Catch (jEnv);
4728
4729 return 0;
4730 }
4731
4732 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent
4733 (JNIEnv *jEnv, jobject jThs, jlong jCh, jstring jName, jstring jNs, jlong jInd)
4734 {
4735 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
4736 CIMInstance *ind = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInd);
4737 const char *str = jEnv->GetStringUTFChars (jName, NULL);
4738 String name (str);
|
4739 mark.hamzy 1.35
|
4740 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jName, str);
|
4741 mark.hamzy 1.35
|
4742 mark.hamzy 1.62 str = jEnv->GetStringUTFChars (jNs, NULL);
|
4743 mark.hamzy 1.35
|
4744 mark.hamzy 1.62 String ns (str);
|
4745 mark.hamzy 1.35
|
4746 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jNs, str);
|
4747 mark.hamzy 1.35
|
4748 mark.hamzy 1.62 CIMObjectPath ref (ind->getPath ());
|
4749 mark.hamzy 1.35
|
4750 mark.hamzy 1.62 ref.setNameSpace (ns);
4751 DDD (PEGASUS_STD (cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent () ref = "<<ref.toString ()<<PEGASUS_STD (endl));
4752 DDD (PEGASUS_STD (cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent () ind = "<<ind->getPath ().toString ()<<PEGASUS_STD (endl));
4753 ind->setPath (ref);
4754 DDD (PEGASUS_STD (cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent () ind = "<<ind->getPath ().toString ()<<PEGASUS_STD (endl));
|
4755 mark.hamzy 1.35
|
4756 mark.hamzy 1.62 JMPIProviderManager::indProvRecord *prec = NULL;
4757 String sPathString = ind->getPath ().toString ();
4758 OperationContext *context = NULL;
4759 bool fResult = false;
|
4760 mark.hamzy 1.35
|
4761 mark.hamzy 1.62 {
4762 AutoMutex lock (JMPIProviderManager::mutexProvTab);
|
4763 mark.hamzy 1.35
|
4764 mark.hamzy 1.62 fResult = JMPIProviderManager::provTab.lookup (name, prec);
|
4765 mark.hamzy 1.35
|
4766 mark.hamzy 1.62 DDD (PEGASUS_STD (cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent () fResult = "<<fResult<<", name = "<<name<<PEGASUS_STD (endl));
4767 }
|
4768 mark.hamzy 1.35
|
4769 mark.hamzy 1.62 if (fResult)
4770 {
4771 if (prec->enabled)
4772 {
4773 try
4774 {
4775 prec->handler->deliver (*prec->ctx, *ind);
4776 }
4777 Catch (jEnv);
|
4778 mark.hamzy 1.35 }
|
4779 mark.hamzy 1.62 }
4780 else
4781 {
4782 DDD (PEGASUS_STD (cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent () provider name \""<<name<<"\" not found"<<PEGASUS_STD (endl));
4783 }
4784 }
|
4785 mark.hamzy 1.35
|
4786 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1finalize
4787 (JNIEnv *jEnv, jobject jThs, jlong jCh)
4788 {
4789 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);
|
4790 mark.hamzy 1.35
|
4791 mark.hamzy 1.62 delete ch;
|
4792 mark.hamzy 1.35
|
4793 mark.hamzy 1.62 DEBUG_ConvertCleanup (jlong, jCh);
4794 }
|
4795 mark.hamzy 1.35
4796
|
4797 mark.hamzy 1.62 // -------------------------------------
4798 // ---
|
4799 mark.hamzy 1.67 // - CIMParameter
4800 // ---
4801 // -------------------------------------
4802
4803 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMParameter__1getName
4804 (JNIEnv *jEnv, jobject jThs, jlong jCp)
4805 {
4806 CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);
4807 jstring rv = 0;
4808
4809 if (cp)
4810 {
4811 try
4812 {
4813 CIMName name = cp->getName ();
4814
4815 rv = jEnv->NewStringUTF (name.getString ().getCString ());
4816 }
4817 Catch (jEnv);
4818 }
4819
4820 mark.hamzy 1.67 return rv;
4821 }
4822
4823 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMParameter__1setName
4824 (JNIEnv *jEnv, jobject jThs, jlong jCp, jstring jName)
4825 {
4826 CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);
4827
4828 if (cp && jName)
4829 {
4830 try
4831 {
4832 const char *cstrName = jEnv->GetStringUTFChars (jName, NULL);
4833
4834 CIMName name (cstrName);
4835
4836 cp->setName (name);
4837
4838 jEnv->ReleaseStringUTFChars (jName, cstrName);
4839 }
4840 Catch (jEnv);
4841 mark.hamzy 1.67 }
4842 }
4843
4844 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMParameter__1isArray
4845 (JNIEnv *jEnv, jobject jThs, jlong jCp)
4846 {
4847 CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);
4848 jboolean rv = 0;
4849
4850 if (cp)
4851 {
4852 try
4853 {
4854 rv = cp->isArray ();
4855 }
4856 Catch (jEnv);
4857 }
4858
4859 return rv;
4860 }
4861
4862 mark.hamzy 1.67 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMParameter__1getArraySize
4863 (JNIEnv *jEnv, jobject jThs, jlong jCp)
4864 {
4865 CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);
4866 jint rv = 0;
4867
4868 if (cp)
4869 {
4870 try
4871 {
4872 rv = cp->getArraySize ();
4873 }
4874 Catch (jEnv);
4875 }
4876
4877 return rv;
4878 }
4879
4880 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMParameter__1getReferenceClassName
4881 (JNIEnv *jEnv, jobject jThs, jlong jCp)
4882 {
4883 mark.hamzy 1.67 CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);
4884 jstring rv = 0;
4885
4886 if (cp)
4887 {
4888 try
4889 {
4890 CIMName name = cp->getReferenceClassName ();
4891
4892 rv = jEnv->NewStringUTF (name.getString ().getCString ());
4893 }
4894 Catch (jEnv);
4895 }
4896
4897 return rv;
4898 }
4899
4900 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMParameter__1getType
4901 (JNIEnv *jEnv, jobject jThs, jlong jCp)
4902 {
4903 CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);
4904 mark.hamzy 1.67 jlong rv = 0;
4905
4906 if (cp)
4907 {
4908 try
4909 {
4910 CIMType ct = cp->getType ();
4911 bool fSuccess = false;
4912 String ref = cp->getReferenceClassName ().getString ();
4913 int iJType = 0;
4914 _dataType *type = 0;
4915
4916 iJType = _dataType::convertCTypeToJavaType (ct, &fSuccess);
4917
4918 if (fSuccess)
4919 {
4920 type = new _dataType (iJType,
4921 cp->getArraySize (),
4922 false,
4923 false,
4924 cp->isArray (),
4925 mark.hamzy 1.67 ref,
4926 true);
4927
4928 rv = DEBUG_ConvertCToJava (_dataType*, jlong, type);
4929 }
4930 }
4931 Catch (jEnv);
4932 }
4933
4934 return rv;
4935 }
4936
4937 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMParameter__1finalize
4938 (JNIEnv *jEnv, jobject jThs, jlong jCp)
4939 {
4940 CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);
4941
4942 delete cp;
4943
4944 DEBUG_ConvertCleanup (jlong, jCp);
4945 }
4946 mark.hamzy 1.67
4947
4948 // -------------------------------------
4949 // ---
|
4950 mark.hamzy 1.62 // - CIMProperty
4951 // ---
4952 // -------------------------------------
|
4953 mark.hamzy 1.35
|
4954 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1getValue
4955 (JNIEnv *jEnv, jobject jThs, jlong jP)
4956 {
4957 CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);
4958 CIMValue *cv = new CIMValue (cp->getValue ());
|
4959 mark.hamzy 1.35
|
4960 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
4961 }
|
4962 mark.hamzy 1.35
|
4963 mark.hamzy 1.62 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getName
4964 (JNIEnv *jEnv, jobject jThs, jlong jP)
4965 {
4966 CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);
4967 const String &n = cp->getName ().getString ();
4968 jstring str = jEnv->NewStringUTF (n.getCString ());
4969
4970 return str;
4971 }
4972
4973 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setName
4974 (JNIEnv *jEnv, jobject jThs, jlong jP, jstring jN)
4975 {
4976 CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);
4977 const char *str = jEnv->GetStringUTFChars (jN,NULL);
|
4978 mark.hamzy 1.35
|
4979 mark.hamzy 1.62 cp->setName (CIMName (str));
|
4980 mark.hamzy 1.35
|
4981 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jN,str);
4982 }
|
4983 mark.hamzy 1.35
|
4984 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1property
4985 (JNIEnv *jEnv, jobject jThs, jstring jN, jlong jV)
4986 {
4987 CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);
4988 const char *str = jEnv->GetStringUTFChars (jN, NULL);
4989 CIMProperty *cp = 0;
4990 jlong jCp = 0;
|
4991 mark.hamzy 1.35
|
4992 mark.hamzy 1.62 try {
4993 if (cv->getType ()!= CIMTYPE_REFERENCE)
4994 {
4995 cp = new CIMProperty (String (str),*cv);
|
4996 mark.hamzy 1.35 }
|
4997 mark.hamzy 1.62 else
|
4998 mark.hamzy 1.35 {
|
4999 mark.hamzy 1.62 if (!cv->isArray ())
5000 {
5001 CIMObjectPath cop;
|
5002 mark.hamzy 1.35
|
5003 mark.hamzy 1.62 cv->get (cop);
5004 cp = new CIMProperty (String (str),*cv,0, cop.getClassName ());
5005 }
5006 else
5007 {
5008 throwCIMException (jEnv,"+++ unsupported type in CIMProperty.property");
5009 }
5010 }
|
5011 mark.hamzy 1.35
|
5012 mark.hamzy 1.62 jCp = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp);
5013 }
5014 Catch (jEnv);
|
5015 mark.hamzy 1.35
|
5016 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jN, str);
|
5017 mark.hamzy 1.56
|
5018 mark.hamzy 1.62 return jCp;
5019 }
|
5020 mark.hamzy 1.56
|
5021 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1new
5022 (JNIEnv *jEnv, jobject jThs, jstring jN, jlong jV)
5023 {
5024 CIMProperty *p = new CIMProperty (CIMName (),CIMValue ());
|
5025 mark.hamzy 1.56
|
5026 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMProperty*, jlong, p);
5027 }
|
5028 mark.hamzy 1.35
|
5029 mark.hamzy 1.62 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isReference
5030 (JNIEnv *jEnv, jobject jThs, jlong jP)
5031 {
5032 CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);
|
5033 mark.hamzy 1.35
|
5034 mark.hamzy 1.62 return (jboolean) (cp->getType () == CIMTYPE_REFERENCE);
5035 }
|
5036 mark.hamzy 1.35
|
5037 mark.hamzy 1.62 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getRefClassName
5038 (JNIEnv *jEnv, jobject jThs, jlong jP)
5039 {
5040 CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);
5041 const String &n = cp->getReferenceClassName ().getString ();
|
5042 mark.hamzy 1.35
|
5043 mark.hamzy 1.62 jstring str = jEnv->NewStringUTF (n.getCString ());
|
5044 mark.hamzy 1.35
|
5045 mark.hamzy 1.62 return str;
5046 }
|
5047 mark.hamzy 1.35
|
5048 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1getType
5049 (JNIEnv *jEnv, jobject jThs, jlong jP)
5050 {
|
5051 mark.hamzy 1.67 CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);
5052 String ref = cp->getReferenceClassName ().getString ();
5053 bool fSuccess = false;
5054 int iJType = 0;
5055 _dataType *type = 0;
|
5056 mark.hamzy 1.35
|
5057 mark.hamzy 1.62 iJType = _dataType::convertCTypeToJavaType (cp->getType (), &fSuccess);
|
5058 mark.hamzy 1.35
|
5059 mark.hamzy 1.62 if (fSuccess)
5060 {
5061 type = new _dataType (iJType,
5062 cp->getArraySize (),
5063 ref.size () ? true : false,
5064 false,
5065 cp->isArray (),
5066 ref,
5067 true);
5068 }
|
5069 mark.hamzy 1.35
|
5070 mark.hamzy 1.62 return DEBUG_ConvertCToJava (_dataType*, jlong, type);
5071 }
|
5072 mark.hamzy 1.35
|
5073 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1setType
5074 (JNIEnv *jEnv, jobject jThs, jlong jP, jlong jDt)
5075 {
5076 CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);
5077 _dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);
5078 CIMValue val;
5079 bool fSuccess = false;
5080 CIMType cType = CIMTYPE_BOOLEAN;
|
5081 mark.hamzy 1.35
|
5082 mark.hamzy 1.62 cType = _dataType::convertJavaTypeToCType (dt->_type, &fSuccess);
|
5083 mark.hamzy 1.35
|
5084 mark.hamzy 1.62 if (fSuccess)
5085 {
5086 val.setNullValue (cType, dt->_array);
|
5087 mark.hamzy 1.35
|
5088 mark.hamzy 1.62 CIMProperty *np = new CIMProperty (cp->getName (), val);
|
5089 mark.hamzy 1.35
|
5090 mark.hamzy 1.62 delete cp;
|
5091 mark.hamzy 1.35
|
5092 mark.hamzy 1.62 DEBUG_ConvertCleanup (jlong, jP);
|
5093 mark.hamzy 1.35
|
5094 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMProperty*, jlong, np);
5095 }
5096 else
5097 {
5098 return DEBUG_ConvertCToJava (CIMProperty*, jlong, cp);
5099 }
5100 }
|
5101 mark.hamzy 1.35
|
5102 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setValue
5103 (JNIEnv *jEnv, jobject jThs, jlong jP,jlong jV)
5104 {
5105 CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);
5106 CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);
|
5107 mark.hamzy 1.35
|
5108 mark.hamzy 1.62 cp->setValue (*cv);
5109 }
|
5110 mark.hamzy 1.35
|
5111 mark.hamzy 1.62 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isArray
5112 (JNIEnv *jEnv, jobject jThs, jlong jP)
5113 {
5114 CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);
|
5115 mark.hamzy 1.35
|
5116 mark.hamzy 1.62 return (jboolean)cp->isArray ();
|
5117 schuur 1.1 }
5118
|
5119 mark.hamzy 1.62 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getIdentifier
5120 (JNIEnv *jEnv, jobject jThs, jlong jP)
|
5121 mark.hamzy 1.20 {
|
5122 mark.hamzy 1.62 CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);
5123 const String &n = cp->getName ().getString ();
5124 jstring str = jEnv->NewStringUTF (n.getCString ());
|
5125 mark.hamzy 1.20
|
5126 mark.hamzy 1.62 return str;
|
5127 schuur 1.1 }
5128
|
5129 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addValue
5130 (JNIEnv *jEnv, jobject jThs, jlong jP, jlong jV)
|
5131 mark.hamzy 1.44 {
|
5132 mark.hamzy 1.62 CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);
5133 CIMValue *cvin = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);
5134 CIMValue cv = cp->getValue ();
|
5135 schuur 1.1
|
5136 mark.hamzy 1.62 if (cvin->isNull ())
5137 throwCIMException (jEnv,"+++ null cvin value ");
5138 if (!cv.isArray ())
5139 throwCIMException (jEnv,"+++ not an array ");
5140 if (cvin->getType ()!= cv.getType ())
5141 throwCIMException (jEnv,"+++ type mismatch ");
|
5142 schuur 1.1
|
5143 mark.hamzy 1.62 CIMType type = cv.getType ();
|
5144 schuur 1.1
|
5145 mark.hamzy 1.62 switch (type)
5146 {
5147 case CIMTYPE_BOOLEAN:
5148 {
5149 Boolean bo;
5150 cvin->get (bo);
5151 Array<Boolean> boarr;
5152 cv.get (boarr);
5153 boarr.append (bo);
5154 cv.set (boarr);
5155 break;
5156 }
5157 case CIMTYPE_UINT8:
5158 {
5159 Uint8 u8;
5160 cvin->get (u8);
5161 Array<Uint8> u8arr;
5162 cv.get (u8arr);
5163 u8arr.append (u8);
5164 cv.set (u8arr);
5165 break;
5166 mark.hamzy 1.62 }
5167 case CIMTYPE_SINT8:
5168 {
5169 Sint8 s8;
5170 cvin->get (s8);
5171 Array<Sint8> s8arr;
5172 cv.get (s8arr);
5173 s8arr.append (s8);
5174 cv.set (s8arr);
5175 break;
5176 }
5177 case CIMTYPE_UINT16:
5178 {
5179 Uint16 u16;
5180 cvin->get (u16);
5181 Array<Uint16> u16arr;
5182 cv.get (u16arr);
5183 u16arr.append (u16);
5184 cv.set (u16arr);
5185 break;
5186 }
5187 mark.hamzy 1.62 case CIMTYPE_SINT16:
5188 {
5189 Sint16 s16;
5190 cvin->get (s16);
5191 Array<Sint16> s16arr;
5192 cv.get (s16arr);
5193 s16arr.append (s16);
5194 cv.set (s16arr);
5195 break;
5196 }
5197 case CIMTYPE_UINT32:
5198 {
5199 Uint32 u32;
5200 cvin->get (u32);
5201 Array<Uint32> u32arr;
5202 cv.get (u32arr);
5203 u32arr.append (u32);
5204 cv.set (u32arr);
5205 break;
5206 }
5207 case CIMTYPE_SINT32:
5208 mark.hamzy 1.62 {
5209 Sint32 s32;
5210 cvin->get (s32);
5211 Array<Sint32> s32arr;
5212 cv.get (s32arr);
5213 s32arr.append (s32);
5214 cv.set (s32arr);
5215 break;
5216 }
5217 case CIMTYPE_UINT64:
5218 {
5219 Uint64 u64;
5220 cvin->get (u64);
5221 Array<Uint64> u64arr;
5222 cv.get (u64arr);
5223 u64arr.append (u64);
5224 cv.set (u64arr);
5225 break;
5226 }
5227 case CIMTYPE_SINT64:
5228 {
5229 mark.hamzy 1.62 Sint64 s64;
5230 cvin->get (s64);
5231 Array<Sint64> s64arr;
5232 cv.get (s64arr);
5233 s64arr.append (s64);
5234 cv.set (s64arr);
5235 break;
5236 }
5237 case CIMTYPE_REAL32:
5238 {
5239 Real32 f;
5240 cvin->get (f);
5241 Array<Real32> farr;
5242 cv.get (farr);
5243 farr.append (f);
5244 cv.set (farr);
5245 break;
5246 }
5247 case CIMTYPE_REAL64:
5248 {
5249 Real64 d;
5250 mark.hamzy 1.62 cvin->get (d);
5251 Array<Real64> darr;
5252 cv.get (darr);
5253 darr.append (d);
5254 cv.set (darr);
5255 break;
5256 }
5257 case CIMTYPE_CHAR16:
5258 {
5259 Char16 c16;
5260 cvin->get (c16);
5261 Array<Char16> c16arr;
5262 cv.get (c16arr);
5263 c16arr.append (c16);
5264 cv.set (c16arr);
5265 break;
5266 }
5267 case CIMTYPE_STRING:
5268 {
5269 String str;
5270 cvin->get (str);
5271 mark.hamzy 1.62 Array<String> strarr;
5272 cv.get (strarr);
5273 strarr.append (str);
5274 cv.set (strarr);
5275 break;
5276 }
5277 case CIMTYPE_DATETIME:
5278 {
5279 CIMDateTime dt;
5280 cvin->get (dt);
5281 Array<CIMDateTime> dtarr;
5282 cv.get (dtarr);
5283 dtarr.append (dt);
5284 cv.set (dtarr);
5285 break;
5286 }
5287 case CIMTYPE_REFERENCE:
5288 {
5289 CIMObjectPath ref;
5290 cvin->get (ref);
5291 Array<CIMObjectPath> refarr;
5292 mark.hamzy 1.62 cv.get (refarr);
5293 refarr.append (ref);
5294 cv.set (refarr);
5295 break;
5296 }
5297 case CIMTYPE_OBJECT:
5298 {
5299 CIMObject obj;
5300 cvin->get (obj);
5301 Array<CIMObject> objarr;
5302 cv.get (objarr);
5303 objarr.append (obj);
5304 cv.set (objarr);
5305 break;
5306 }
5307 default:
|
5308 mark.hamzy 1.44 {
|
5309 mark.hamzy 1.62 throwCIMException (jEnv,"+++ unsupported type ");
|
5310 schuur 1.1 }
5311 }
|
5312 mark.hamzy 1.56
|
5313 mark.hamzy 1.62 cp->setValue (cv);
|
5314 schuur 1.1 }
5315
|
5316 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addQualifier
5317 (JNIEnv *jEnv, jobject jThs, jlong jP, jlong jQ)
|
5318 mark.hamzy 1.44 {
|
5319 mark.hamzy 1.62 CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);
5320 CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ);
|
5321 schuur 1.1
|
5322 mark.hamzy 1.62 cp->addQualifier (*cq);
|
5323 schuur 1.1 }
5324
|
5325 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1finalize
5326 (JNIEnv *jEnv, jobject jThs, jlong jP)
|
5327 mark.hamzy 1.20 {
|
5328 mark.hamzy 1.62 CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);
|
5329 schuur 1.1
|
5330 mark.hamzy 1.62 delete cp;
|
5331 mark.hamzy 1.20
|
5332 mark.hamzy 1.62 DEBUG_ConvertCleanup (jlong, jP);
|
5333 schuur 1.1 }
5334
|
5335 mark.hamzy 1.62 /*
5336 * Class: org_pegasus_jmpi_CIMProperty
5337 * Method: _findQualifier
5338 * Signature: (Ljava/lang/String;)I
5339 */
5340 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1findQualifier
5341 (JNIEnv *jEnv, jobject jThs, jlong jP, jstring jQualifier)
|
5342 mark.hamzy 1.20 {
|
5343 mark.hamzy 1.62 CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);
5344 const char *str = jEnv->GetStringUTFChars (jQualifier, NULL);
5345 Uint32 index = PEG_NOT_FOUND;
|
5346 mark.hamzy 1.20
|
5347 mark.hamzy 1.62 try
5348 {
5349 index = cp->findQualifier (CIMName (str));
|
5350 mark.hamzy 1.20
|
5351 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jQualifier, str);
5352 }
5353 Catch (jEnv);
|
5354 schuur 1.1
|
5355 mark.hamzy 1.62 return index;
|
5356 schuur 1.1 }
5357
|
5358 mark.hamzy 1.62 /*
5359 * Class: org_pegasus_jmpi_CIMProperty
5360 * Method: _getQualifier
5361 * Signature: (I)I
5362 */
5363 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1getQualifier
5364 (JNIEnv *jEnv, jobject jThs, jlong jP, jint jIndex)
|
5365 mark.hamzy 1.20 {
|
5366 mark.hamzy 1.62 CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);
5367 CIMQualifier *cq = NULL;
5368 CIMQualifier qualifier;
|
5369 mark.hamzy 1.20
|
5370 mark.hamzy 1.62 try
5371 {
5372 qualifier = cp->getQualifier ((Uint32)jIndex);
5373 cq = new CIMQualifier (qualifier);
5374 }
5375 Catch (jEnv);
|
5376 schuur 1.1
|
5377 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMQualifier *, jlong, cq);
|
5378 schuur 1.1 }
5379
|
5380 mark.hamzy 1.22
|
5381 schuur 1.1 // -------------------------------------
5382 // ---
|
5383 mark.hamzy 1.62 // - CIMQualifier
|
5384 schuur 1.1 // ---
5385 // -------------------------------------
5386
|
5387 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMQualifier__1new
5388 (JNIEnv *jEnv, jobject jThs, jstring jN)
|
5389 mark.hamzy 1.20 {
|
5390 mark.hamzy 1.62 const char *str = jEnv->GetStringUTFChars (jN,NULL);
5391 CIMQualifier *qual = new CIMQualifier (CIMName (str),CIMValue ());
|
5392 mark.hamzy 1.20
|
5393 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jN,str);
|
5394 schuur 1.4
|
5395 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMQualifier*, jlong, qual);
|
5396 schuur 1.4 }
5397
|
5398 mark.hamzy 1.62 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getName
5399 (JNIEnv *jEnv, jobject jThs, jlong jQ)
|
5400 mark.hamzy 1.20 {
|
5401 mark.hamzy 1.62 CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ);
5402 const String &n = cq->getName ().getString ();
5403 jstring str = jEnv->NewStringUTF (n.getCString ());
|
5404 mark.hamzy 1.20
|
5405 mark.hamzy 1.62 return str;
|
5406 schuur 1.1 }
5407
|
5408 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getValue
5409 (JNIEnv *jEnv, jobject jThs, jlong jQ)
|
5410 mark.hamzy 1.20 {
|
5411 mark.hamzy 1.62 CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ);
5412 CIMValue *cv = new CIMValue (cq->getValue ());
|
5413 mark.hamzy 1.20
|
5414 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
|
5415 schuur 1.1 }
5416
|
5417 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1setValue
5418 (JNIEnv *jEnv, jobject jThs, jlong jQ,jlong jV)
|
5419 mark.hamzy 1.20 {
|
5420 mark.hamzy 1.62 CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ);
5421 CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);
|
5422 schuur 1.1
|
5423 mark.hamzy 1.62 cq->setValue (*cv);
|
5424 schuur 1.1 }
5425
|
5426 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1finalize
5427 (JNIEnv *jEnv, jobject jThs, jlong jQ)
|
5428 mark.hamzy 1.20 {
|
5429 mark.hamzy 1.62 CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ);
|
5430 mark.hamzy 1.20
|
5431 mark.hamzy 1.62 delete cq;
|
5432 schuur 1.1
|
5433 mark.hamzy 1.62 DEBUG_ConvertCleanup (jlong, jQ);
|
5434 schuur 1.5 }
5435
5436
|
5437 schuur 1.1 // -------------------------------------
5438 // ---
|
5439 mark.hamzy 1.62 // - CIMQualifierType
|
5440 schuur 1.1 // ---
5441 // -------------------------------------
5442
|
5443 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1new
5444 (JNIEnv *jEnv, jobject jThs)
|
5445 mark.hamzy 1.44 {
|
5446 mark.hamzy 1.62 CIMQualifierDecl *qual = new CIMQualifierDecl ();
|
5447 mark.hamzy 1.30
|
5448 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMQualifierDecl*, jlong, qual);
|
5449 schuur 1.5 }
5450
|
5451 mark.hamzy 1.62 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1getName
5452 (JNIEnv *jEnv, jobject jThs, jlong jQ)
|
5453 mark.hamzy 1.20 {
|
5454 mark.hamzy 1.62 CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jlong, CIMQualifierDecl*, jQ);
5455 const String &n = qt->getName ().getString ();
5456 jstring str = jEnv->NewStringUTF (n.getCString ());
|
5457 schuur 1.5
|
5458 mark.hamzy 1.62 return str;
|
5459 schuur 1.1 }
5460
|
5461 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setName
5462 (JNIEnv *jEnv, jobject jThs, jlong jQ, jstring jN)
|
5463 mark.hamzy 1.20 {
|
5464 mark.hamzy 1.62 CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jlong, CIMQualifierDecl*, jQ);
5465 const char *str = jEnv->GetStringUTFChars (jN, NULL);
5466 jlong jret = 0;
|
5467 mark.hamzy 1.54
|
5468 mark.hamzy 1.62 if (qt->isUninitialized ())
|
5469 mark.hamzy 1.54 {
|
5470 mark.hamzy 1.62 CIMQualifierDecl *nqt = new CIMQualifierDecl (CIMName (str), CIMValue (), CIMScope ());
|
5471 mark.hamzy 1.54
|
5472 mark.hamzy 1.62 jret = DEBUG_ConvertCToJava (CIMQualifierDecl*, jlong, nqt);
5473 }
5474 else
5475 {
5476 qt->setName (CIMName (str));
|
5477 mark.hamzy 1.20
|
5478 mark.hamzy 1.62 CIMQualifierDecl *nqt = new CIMQualifierDecl (*qt);
|
5479 mark.hamzy 1.54
|
5480 mark.hamzy 1.62 jret = DEBUG_ConvertCToJava (CIMQualifierDecl*, jlong, nqt);
|
5481 schuur 1.1 }
|
5482 mark.hamzy 1.20
|
5483 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jN, str);
5484
5485 return jret;
|
5486 schuur 1.1 }
|
5487 schuur 1.3
|
5488 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setValue
5489 (JNIEnv *jEnv, jobject jThs, jlong jQ,jlong jV)
|
5490 mark.hamzy 1.20 {
|
5491 mark.hamzy 1.62 CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jlong, CIMQualifierDecl*, jQ);
5492 CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);
|
5493 mark.hamzy 1.20
|
5494 mark.hamzy 1.62 qt->setValue (*cv);
|
5495 schuur 1.3 }
5496
|
5497 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1finalize
5498 (JNIEnv *jEnv, jobject jThs, jlong jQ)
|
5499 mark.hamzy 1.20 {
|
5500 mark.hamzy 1.62 CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jlong, CIMQualifierDecl*, jQ);
5501
5502 delete qt;
|
5503 schuur 1.3
|
5504 mark.hamzy 1.62 DEBUG_ConvertCleanup (jlong, jQ);
|
5505 schuur 1.3 }
5506
|
5507 mark.hamzy 1.62 // -------------------------------------
5508 // ---
5509 // - CIMValue
5510 // ---
5511 // -------------------------------------
5512
5513 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1byte
5514 (JNIEnv *jEnv, jobject jThs, jbyte jb, jboolean notSigned)
|
5515 mark.hamzy 1.20 {
|
5516 mark.hamzy 1.62 CIMValue *cv = NULL;
|
5517 schuur 1.3
|
5518 mark.hamzy 1.62 if (notSigned)
5519 cv = new CIMValue ((Uint8)jb);
5520 else
5521 cv = new CIMValue ((Sint8)jb);
|
5522 mark.hamzy 1.56
|
5523 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
|
5524 schuur 1.1 }
|
5525 schuur 1.3
|
5526 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1short
5527 (JNIEnv *jEnv, jobject jThs, jshort js, jboolean notSigned)
|
5528 mark.hamzy 1.20 {
|
5529 mark.hamzy 1.62 CIMValue *cv = NULL;
5530
5531 if (notSigned)
5532 cv = new CIMValue ((Uint16)js);
5533 else
5534 cv = new CIMValue( (Sint16)js);
|
5535 mark.hamzy 1.20
|
5536 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
5537 }
|
5538 mark.hamzy 1.56
|
5539 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1makeInt
5540 (JNIEnv *jEnv, jobject jThs, jlong ji, jboolean notSigned)
5541 {
5542 CIMValue *cv = NULL;
|
5543 mark.hamzy 1.56
|
5544 mark.hamzy 1.62 if (notSigned)
5545 cv = new CIMValue ((Uint32)ji);
5546 else
5547 cv = new CIMValue ((Sint32)ji);
|
5548 mark.hamzy 1.20
|
5549 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
|
5550 schuur 1.1 }
5551
|
5552 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1long
5553 (JNIEnv *jEnv, jobject jThs, jlong jl, jboolean notSigned)
|
5554 mark.hamzy 1.20 {
|
5555 mark.hamzy 1.62 CIMValue *cv = NULL;
|
5556 mark.hamzy 1.20
|
5557 mark.hamzy 1.62 if (notSigned)
5558 cv = new CIMValue ((Uint64)jl);
5559 else
5560 cv = new CIMValue ((Sint64)jl);
|
5561 mark.hamzy 1.56
|
5562 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
5563 }
|
5564 mark.hamzy 1.56
|
5565 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1string
5566 (JNIEnv *jEnv, jobject jThs, jstring jS)
5567 {
5568 const char *str = jEnv->GetStringUTFChars (jS,NULL);
5569 CIMValue *cv = new CIMValue (String (str));
|
5570 mark.hamzy 1.56
|
5571 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jS,str);
|
5572 mark.hamzy 1.20
|
5573 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
|
5574 schuur 1.3 }
5575
|
5576 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1boolean
5577 (JNIEnv *jEnv, jobject jThs, jboolean jB)
|
5578 mark.hamzy 1.20 {
|
5579 mark.hamzy 1.62 CIMValue *cv = new CIMValue ((Boolean)jB);
5580
5581 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
5582 }
|
5583 mark.hamzy 1.20
|
5584 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1float
5585 (JNIEnv *jEnv, jobject jThs, jfloat jF)
5586 {
5587 CIMValue *cv = new CIMValue (jF);
|
5588 mark.hamzy 1.24
|
5589 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
5590 }
|
5591 mark.hamzy 1.24
|
5592 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1double
5593 (JNIEnv *jEnv, jobject jThs, jdouble jD)
5594 {
5595 CIMValue *cv = new CIMValue (jD);
|
5596 mark.hamzy 1.20
|
5597 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
|
5598 schuur 1.6 }
5599
|
5600 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1cop
5601 (JNIEnv *jEnv, jobject jThs, jlong jR)
|
5602 mark.hamzy 1.20 {
|
5603 mark.hamzy 1.62 CIMObjectPath *ref = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jR);
5604 CIMValue *cv = new CIMValue (*ref);
|
5605 schuur 1.5
|
5606 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
5607 }
|
5608 mark.hamzy 1.24
|
5609 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1datetime
5610 (JNIEnv *jEnv, jobject jThs, jlong jDT)
5611 {
5612 CIMDateTime *dt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jDT);
5613 CIMValue *cv = new CIMValue (*dt);
|
5614 mark.hamzy 1.56
|
5615 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
5616 }
|
5617 mark.hamzy 1.24
|
5618 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1char16
5619 (JNIEnv *jEnv, jobject jThs, jchar jChar16)
5620 {
5621 Char16 c16 (jChar16);
5622 CIMValue *cv = new CIMValue (c16);
|
5623 mark.hamzy 1.20
|
5624 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
|
5625 schuur 1.1 }
5626
|
5627 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1object
5628 (JNIEnv *jEnv, jobject jThs, jlong jO)
|
5629 mark.hamzy 1.20 {
|
5630 mark.hamzy 1.62 CIMObject *co = DEBUG_ConvertJavaToC (jlong, CIMObject*, jO);
5631 CIMValue *cv = new CIMValue (*co);
|
5632 mark.hamzy 1.20
|
5633 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
|
5634 schuur 1.3 }
5635
|
5636 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1byteArray
5637 (JNIEnv *jEnv, jobject jThs, jshortArray jshortA, jboolean notSigned)
|
5638 mark.hamzy 1.20 {
|
5639 mark.hamzy 1.62 CIMValue *cv = NULL;
5640 jboolean b;
5641 jsize len = jEnv->GetArrayLength (jshortA);
5642 jshort *jsA = jEnv->GetShortArrayElements (jshortA, &b);
5643
5644 if (notSigned)
5645 {
5646 Array<Uint8> u8;
|
5647 mark.hamzy 1.20
|
5648 mark.hamzy 1.62 for (jsize i = 0; i < len; i++)
5649 u8.append ((Uint8)jsA[i]);
|
5650 mark.hamzy 1.56
|
5651 mark.hamzy 1.62 cv = new CIMValue (u8);
5652 }
5653 else
5654 {
5655 Array<Sint8> s8;
|
5656 mark.hamzy 1.56
|
5657 mark.hamzy 1.62 for (jsize i = 0; i < len; i++)
5658 s8.append ((Sint8)jsA[i]);
|
5659 mark.hamzy 1.56
|
5660 mark.hamzy 1.62 cv = new CIMValue (s8);
|
5661 schuur 1.1 }
|
5662 mark.hamzy 1.20
|
5663 mark.hamzy 1.62 jEnv->ReleaseShortArrayElements (jshortA, jsA, len);
5664
5665 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
|
5666 schuur 1.1 }
|
5667 schuur 1.3
|
5668 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1shortArray
5669 (JNIEnv *jEnv, jobject jThs, jintArray jintA, jboolean notSigned)
|
5670 mark.hamzy 1.20 {
|
5671 mark.hamzy 1.62 CIMValue *cv = NULL;
5672 jboolean b;
5673 jsize len = jEnv->GetArrayLength (jintA);
5674 jint *jiA = jEnv->GetIntArrayElements (jintA, &b);
|
5675 mark.hamzy 1.20
|
5676 mark.hamzy 1.62 if (notSigned)
5677 {
5678 Array<Uint16> u16;
|
5679 mark.hamzy 1.56
|
5680 mark.hamzy 1.62 for (jsize i = 0; i < len; i++)
5681 u16.append ((Uint16)jiA[i]);
|
5682 mark.hamzy 1.56
|
5683 mark.hamzy 1.62 cv = new CIMValue (u16);
|
5684 schuur 1.1 }
|
5685 mark.hamzy 1.62 else
5686 {
5687 Array<Sint16> s16;
|
5688 schuur 1.3
|
5689 mark.hamzy 1.62 for (jsize i = 0; i < len; i++)
5690 s16.append ((Sint16)jiA[i]);
|
5691 mark.hamzy 1.20
|
5692 mark.hamzy 1.62 cv = new CIMValue (s16);
5693 }
|
5694 mark.hamzy 1.56
|
5695 mark.hamzy 1.62 jEnv->ReleaseIntArrayElements (jintA, jiA, len);
|
5696 mark.hamzy 1.56
|
5697 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
|
5698 schuur 1.3 }
5699
|
5700 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1intArray
5701 (JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned)
|
5702 mark.hamzy 1.20 {
|
5703 mark.hamzy 1.62 CIMValue *cv = NULL;
5704 jboolean b;
5705 jsize len = jEnv->GetArrayLength (jlongA);
5706 jlong *jlA = jEnv->GetLongArrayElements (jlongA, &b);
5707
5708 if (notSigned)
5709 {
5710 Array<Uint32> u32;
5711
5712 for (jsize i = 0; i < len; i++)
5713 u32.append ((Uint32)jlA[i]);
|
5714 mark.hamzy 1.20
|
5715 mark.hamzy 1.62 cv = new CIMValue (u32);
5716 }
5717 else
5718 {
5719 Array<Sint32> s32;
|
5720 mark.hamzy 1.56
|
5721 mark.hamzy 1.62 for (jsize i = 0; i < len; i++)
5722 s32.append ((Sint32)jlA[i]);
|
5723 mark.hamzy 1.56
|
5724 mark.hamzy 1.62 cv = new CIMValue (s32);
|
5725 schuur 1.3 }
|
5726 mark.hamzy 1.20
|
5727 mark.hamzy 1.62 jEnv->ReleaseLongArrayElements (jlongA, jlA, len);
5728
5729 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
|
5730 schuur 1.5 }
5731
|
5732 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1longArray
5733 (JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned)
|
5734 mark.hamzy 1.20 {
|
5735 mark.hamzy 1.62 CIMValue *cv = NULL;
5736 jboolean b;
5737 jsize len = jEnv->GetArrayLength (jlongA);
5738 jlong *jlA = jEnv->GetLongArrayElements (jlongA, &b);
|
5739 mark.hamzy 1.20
|
5740 mark.hamzy 1.62 if (notSigned)
5741 {
5742 Array<Uint64> u64;
|
5743 mark.hamzy 1.56
|
5744 mark.hamzy 1.62 for (jsize i = 0; i < len; i++)
5745 u64.append ((Uint64)jlA[i]);
|
5746 mark.hamzy 1.56
|
5747 mark.hamzy 1.62 cv = new CIMValue (u64);
|
5748 schuur 1.3 }
|
5749 mark.hamzy 1.62 else
5750 {
5751 Array<Sint64> s64;
|
5752 mark.hamzy 1.20
|
5753 mark.hamzy 1.62 for (jsize i = 0; i < len; i++)
5754 s64.append ((Sint64)jlA[i]);
|
5755 schuur 1.3
|
5756 mark.hamzy 1.62 cv = new CIMValue (s64);
5757 }
|
5758 mark.hamzy 1.20
|
5759 mark.hamzy 1.62 jEnv->ReleaseLongArrayElements (jlongA, jlA, len);
|
5760 mark.hamzy 1.56
|
5761 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
|
5762 schuur 1.5 }
5763
|
5764 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1stringArray
5765 (JNIEnv *jEnv, jobject jThs, jobjectArray jstringA)
|
5766 mark.hamzy 1.20 {
|
5767 mark.hamzy 1.62 CIMValue *cv = NULL;
5768 jsize len = jEnv->GetArrayLength (jstringA);
5769 Array<String> strA;
5770
5771 for (jsize i = 0;i < len; i++)
5772 {
5773 jstring jsA = (jstring)jEnv->GetObjectArrayElement (jstringA, i);
5774 const char *str = jEnv->GetStringUTFChars (jsA, NULL);
|
5775 mark.hamzy 1.20
|
5776 mark.hamzy 1.62 strA.append (String (str));
|
5777 mark.hamzy 1.56
|
5778 mark.hamzy 1.62 jEnv->ReleaseStringUTFChars (jsA, str);
|
5779 schuur 1.5 }
|
5780 mark.hamzy 1.62
5781 cv = new CIMValue (strA);
5782
5783 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
|
5784 schuur 1.5 }
5785
|
5786 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1booleanArray
5787 (JNIEnv *jEnv, jobject jThs, jbooleanArray jboolA)
|
5788 mark.hamzy 1.20 {
|
5789 mark.hamzy 1.62 CIMValue *cv = NULL;
5790 jboolean b;
5791 jsize len = jEnv->GetArrayLength (jboolA);
5792 jboolean *jbA = jEnv->GetBooleanArrayElements (jboolA, &b);
5793 Array<Boolean> bA;
|
5794 mark.hamzy 1.20
|
5795 mark.hamzy 1.62 for (jsize i = 0; i < len; i++)
5796 bA.append ((Boolean)jbA[i]);
|
5797 mark.hamzy 1.27
|
5798 mark.hamzy 1.62 cv = new CIMValue (bA);
|
5799 mark.hamzy 1.27
|
5800 mark.hamzy 1.62 jEnv->ReleaseBooleanArrayElements (jboolA, jbA, len);
|
5801 mark.hamzy 1.20
|
5802 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
|
5803 schuur 1.3 }
|
5804 schuur 1.5
|
5805 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1floatArray
5806 (JNIEnv *jEnv, jobject jThs, jfloatArray jfloatA)
|
5807 mark.hamzy 1.20 {
|
5808 mark.hamzy 1.62 CIMValue *cv = NULL;
5809 jboolean b;
5810 jsize len = jEnv->GetArrayLength (jfloatA);
5811 jfloat *jfA = jEnv->GetFloatArrayElements (jfloatA, &b);
5812 Array<float> fA;
5813
5814 for (jsize i = 0; i< len; i++)
5815 fA.append ((float)jfA[i]);
|
5816 mark.hamzy 1.20
|
5817 mark.hamzy 1.62 cv = new CIMValue (fA);
|
5818 mark.hamzy 1.56
|
5819 mark.hamzy 1.62 jEnv->ReleaseFloatArrayElements (jfloatA, jfA, len);
|
5820 mark.hamzy 1.27
|
5821 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
|
5822 schuur 1.3 }
5823
|
5824 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1doubleArray
5825 (JNIEnv *jEnv, jobject jThs, jdoubleArray jdoubleA)
|
5826 mark.hamzy 1.20 {
|
5827 mark.hamzy 1.62 CIMValue *cv = NULL;
5828 jboolean b;
5829 jsize len = jEnv->GetArrayLength (jdoubleA);
5830 jdouble *jdA = jEnv->GetDoubleArrayElements (jdoubleA, &b);
5831 Array<double> dA;
|
5832 mark.hamzy 1.30
|
5833 mark.hamzy 1.62 for (jsize i = 0; i < len; i++)
5834 dA.append ((double)jdA[i]);
|
5835 mark.hamzy 1.20
|
5836 mark.hamzy 1.62 cv = new CIMValue (dA);
|
5837 mark.hamzy 1.56
|
5838 mark.hamzy 1.62 jEnv->ReleaseDoubleArrayElements (jdoubleA, jdA, len);
|
5839 mark.hamzy 1.20
|
5840 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
5841 }
|
5842 mark.hamzy 1.20
|
5843 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1copArray
5844 (JNIEnv *jEnv, jobject jThs, jlongArray jlongA)
5845 {
5846 CIMValue *cv = NULL;
5847 jboolean b;
5848 jsize len = jEnv->GetArrayLength (jlongA);
5849 jlong *jiA = jEnv->GetLongArrayElements (jlongA, &b);
5850 Array<CIMObjectPath> cA;
|
5851 mark.hamzy 1.20
|
5852 mark.hamzy 1.62 for (jsize i = 0; i < len; i++)
5853 {
5854 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jiA[i]);
5855 cA.append (*cop);
|
5856 schuur 1.3 }
|
5857 mark.hamzy 1.27
|
5858 mark.hamzy 1.62 cv = new CIMValue (cA);
|
5859 mark.hamzy 1.27
|
5860 mark.hamzy 1.62 jEnv->ReleaseLongArrayElements (jlongA, jiA, len);
|
5861 schuur 1.3
|
5862 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
5863 }
|
5864 mark.hamzy 1.20
|
5865 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1datetimeArray
5866 (JNIEnv *jEnv, jobject jThs, jlongArray jlongA)
5867 {
5868 CIMValue *cv = NULL;
5869 jboolean b;
5870 jsize len = jEnv->GetArrayLength (jlongA);
5871 jlong *jiA = jEnv->GetLongArrayElements (jlongA, &b);
5872 Array<CIMDateTime> cA;
|
5873 mark.hamzy 1.27
|
5874 mark.hamzy 1.62 for (jsize i = 0; i < len; i++)
5875 {
5876 CIMDateTime *cdt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jiA[i]);
5877 cA.append (*cdt);
|
5878 mark.hamzy 1.20 }
5879
|
5880 mark.hamzy 1.62 cv = new CIMValue (cA);
5881
5882 jEnv->ReleaseLongArrayElements (jlongA, jiA, len);
|
5883 mark.hamzy 1.27
|
5884 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
|
5885 schuur 1.3 }
5886
|
5887 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1objectArray
5888 (JNIEnv *jEnv, jobject jThs, jlongArray jlongA)
|
5889 mark.hamzy 1.20 {
|
5890 mark.hamzy 1.62 CIMValue *cv = NULL;
5891 jboolean b;
5892 jsize len = jEnv->GetArrayLength (jlongA);
5893 jlong *jiA = jEnv->GetLongArrayElements (jlongA, &b);
5894 Array<CIMObject> cA;
|
5895 mark.hamzy 1.30
|
5896 mark.hamzy 1.62 for (jsize i = 0; i < len; i++)
|
5897 mark.hamzy 1.43 {
|
5898 mark.hamzy 1.62 CIMObject *co = DEBUG_ConvertJavaToC (jlong, CIMObject*, jiA[i]);
5899 cA.append (*co);
5900 }
|
5901 mark.hamzy 1.20
|
5902 mark.hamzy 1.62 cv = new CIMValue (cA);
|
5903 mark.hamzy 1.56
|
5904 mark.hamzy 1.62 jEnv->ReleaseLongArrayElements (jlongA, jiA, len);
|
5905 mark.hamzy 1.20
|
5906 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
5907 }
|
5908 mark.hamzy 1.20
|
5909 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1char16Array
5910 (JNIEnv *jEnv, jobject jThs, jcharArray jcharA)
5911 {
5912 CIMValue *cv = NULL;
5913 jboolean b;
5914 jsize len = jEnv->GetArrayLength (jcharA);
5915 jchar *jcA = jEnv->GetCharArrayElements (jcharA, &b);
5916 Array<Char16> cA;
|
5917 mark.hamzy 1.20
|
5918 mark.hamzy 1.62 for (jsize i = 0; i < len; i++)
5919 cA.append (Char16 (jcA[i]));
|
5920 mark.hamzy 1.56
|
5921 mark.hamzy 1.62 cv = new CIMValue (cA);
|
5922 schuur 1.7
|
5923 mark.hamzy 1.62 jEnv->ReleaseCharArrayElements (jcharA, jcA, len);
|
5924 mark.hamzy 1.43
|
5925 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
|
5926 schuur 1.6 }
5927
|
5928 mark.hamzy 1.62 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMValue__1getValue
5929 (JNIEnv *jEnv, jobject jThs, jlong jV)
|
5930 mark.hamzy 1.20 {
|
5931 mark.hamzy 1.62 JMPIjvm::cacheIDs (jEnv);
|
5932 schuur 1.3
|
5933 mark.hamzy 1.62 CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);
|
5934 mark.hamzy 1.16
|
5935 mark.hamzy 1.62 if (cv->isNull ())
5936 return NULL;
|
5937 mark.hamzy 1.16
|
5938 mark.hamzy 1.62 CIMType type = cv->getType ();
|
5939 mark.hamzy 1.27
|
5940 mark.hamzy 1.62 if (!cv->isArray ())
5941 {
5942 switch (type)
5943 {
5944 case CIMTYPE_BOOLEAN:
5945 {
5946 Boolean bo;
5947 cv->get (bo);
5948 return jEnv->NewObject (JMPIjvm::jv.BooleanClassRef,
5949 JMPIjvm::jv.BooleanNewZ,
5950 (jboolean)bo);
5951 }
5952 case CIMTYPE_SINT8:
5953 {
5954 Sint8 s8;
5955 cv->get (s8);
5956 return jEnv->NewObject (JMPIjvm::jv.ByteClassRef,
5957 JMPIjvm::jv.ByteNewB,
5958 (jbyte)s8);
5959 }
5960 case CIMTYPE_UINT8:
5961 mark.hamzy 1.62 {
5962 Uint8 u8;
5963 cv->get (u8);
5964 return jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef,
5965 JMPIjvm::jv.UnsignedInt8NewS,
5966 (jshort)u8);
5967 }
5968 case CIMTYPE_SINT16:
5969 {
5970 Sint16 s16;
5971 cv->get (s16);
5972 return jEnv->NewObject (JMPIjvm::jv.ShortClassRef,
5973 JMPIjvm::jv.ShortNewS,
5974 (jshort)s16);
5975 }
5976 case CIMTYPE_UINT16:
5977 {
5978 Uint16 u16;
5979 cv->get (u16);
5980 return jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef,
5981 JMPIjvm::jv.UnsignedInt16NewI,
5982 mark.hamzy 1.62 (jint)u16);
5983 }
5984 case CIMTYPE_SINT32:
5985 {
5986 Sint32 s32;
5987 cv->get (s32);
5988 return jEnv->NewObject (JMPIjvm::jv.IntegerClassRef,
5989 JMPIjvm::jv.IntegerNewI,
5990 (jint)s32);
5991 }
5992 case CIMTYPE_UINT32:
5993 {
5994 Uint32 u32;
5995 cv->get (u32);
5996 return jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef,
5997 JMPIjvm::jv.UnsignedInt32NewJ,
5998 (jlong)u32);
5999 }
6000 case CIMTYPE_SINT64:
6001 {
6002 Sint64 s64;
6003 mark.hamzy 1.62 cv->get (s64);
6004 return jEnv->NewObject (JMPIjvm::jv.LongClassRef,
6005 JMPIjvm::jv.LongNewJ,
6006 (jlong)s64);
6007 }
6008 case CIMTYPE_UINT64:
6009 {
6010 Uint64 u64;
|
6011 mark.hamzy 1.56
|
6012 mark.hamzy 1.62 cv->get (u64);
|
6013 mark.hamzy 1.56
|
6014 mark.hamzy 1.62 std::ostringstream oss;
6015 jstring jString = 0;
6016 jobject jBIG = 0;
|
6017 mark.hamzy 1.20
|
6018 mark.hamzy 1.62 oss << u64 << ends;
|
6019 schuur 1.3
|
6020 mark.hamzy 1.62 jString = jEnv->NewStringUTF (oss.str ().c_str ());
|
6021 mark.hamzy 1.44
|
6022 mark.hamzy 1.62 if (jString)
6023 {
6024 jBIG = jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,
6025 JMPIjvm::jv.UnsignedInt64NewStr,
6026 jString);
6027 }
|
6028 mark.hamzy 1.44
|
6029 mark.hamzy 1.62 return jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,
6030 JMPIjvm::jv.UnsignedInt64NewBi,
6031 jBIG);
6032 }
6033 case CIMTYPE_REAL32:
6034 {
6035 float f;
6036 cv->get (f);
6037 return jEnv->NewObject (JMPIjvm::jv.FloatClassRef,
6038 JMPIjvm::jv.FloatNewF,
6039 (jfloat)f);
6040 }
6041 case CIMTYPE_REAL64:
6042 {
6043 double d;
6044 cv->get (d);
6045 return jEnv->NewObject (JMPIjvm::jv.DoubleClassRef,
6046 JMPIjvm::jv.DoubleNewD,
6047 (jdouble)d);
6048 }
6049 case CIMTYPE_STRING:
6050 mark.hamzy 1.62 {
6051 String s;
6052 cv->get (s);
6053 return jEnv->NewStringUTF (s.getCString ());
6054 }
6055 case CIMTYPE_REFERENCE:
6056 {
6057 CIMObjectPath ref;
6058 cv->get (ref);
6059 jlong jOp = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, new CIMObjectPath (ref));
6060 return jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef,
6061 JMPIjvm::jv.CIMObjectPathNewJ,
6062 jOp);
6063 }
6064 case CIMTYPE_CHAR16:
6065 {
6066 Char16 c16;
6067 cv->get (c16);
6068 return jEnv->NewObject (JMPIjvm::jv.CharacterClassRef,
6069 JMPIjvm::jv.CharacterNewC,
6070 (jchar)c16);
6071 mark.hamzy 1.62 }
6072 case CIMTYPE_DATETIME:
|
6073 mark.hamzy 1.44 {
|
6074 mark.hamzy 1.62 CIMDateTime dt;
6075 cv->get (dt);
6076 jlong jDT = DEBUG_ConvertCToJava (CIMDateTime*, jlong, new CIMDateTime (dt));
6077 return jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef,
6078 JMPIjvm::jv.CIMDateTimeNewJ,
6079 jDT);
|
6080 mark.hamzy 1.44 }
|
6081 mark.hamzy 1.62 case CIMTYPE_OBJECT:
|
6082 mark.hamzy 1.44 {
|
6083 mark.hamzy 1.62 CIMObject co;
6084 cv->get (co);
6085 if (co.isClass ())
6086 {
6087 jlong jCC = DEBUG_ConvertCToJava (CIMClass*, jlong, new CIMClass (co));
|
6088 mark.hamzy 1.44
|
6089 mark.hamzy 1.62 return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,
6090 JMPIjvm::jv.CIMObjectNewJZ,
6091 jCC,
6092 (jboolean)true);
6093 }
6094 else
6095 {
6096 jlong jCI = DEBUG_ConvertCToJava (CIMInstance*, jlong, new CIMInstance (co));
|
6097 mark.hamzy 1.44
|
6098 mark.hamzy 1.62 return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,
6099 JMPIjvm::jv.CIMObjectNewJZ,
6100 jCI,
6101 (jboolean)false);
6102 }
6103 }
6104 default:
6105 throwCIMException (jEnv,"+++ unsupported type: ");
|
6106 mark.hamzy 1.44 }
6107 }
|
6108 mark.hamzy 1.62 else
|
6109 mark.hamzy 1.44 {
|
6110 mark.hamzy 1.62 switch (type)
|
6111 mark.hamzy 1.44 {
|
6112 mark.hamzy 1.62 case CIMTYPE_BOOLEAN:
|
6113 mark.hamzy 1.44 {
|
6114 mark.hamzy 1.62 Array<Boolean> bo;
6115
6116 cv->get (bo);
|
6117 mark.hamzy 1.44
|
6118 mark.hamzy 1.62 int s = bo.size ();
6119 jobjectArray jbooleanA = (jobjectArray)jEnv->NewObjectArray (s,
6120 JMPIjvm::jv.BooleanClassRef,
6121 0);
|
6122 mark.hamzy 1.44
|
6123 mark.hamzy 1.62 for (int i = 0; i < s; i++)
6124 jEnv->SetObjectArrayElement (jbooleanA,
6125 i,
6126 jEnv->NewObject (JMPIjvm::jv.BooleanClassRef,
6127 JMPIjvm::jv.BooleanNewZ,
6128 (jboolean)bo[i]));
6129 return jbooleanA;
|
6130 mark.hamzy 1.44 }
|
6131 mark.hamzy 1.62 case CIMTYPE_SINT8:
6132 {
6133 Array<Sint8> s8;
|
6134 schuur 1.3
|
6135 mark.hamzy 1.62 cv->get (s8);
|
6136 mark.hamzy 1.20
|
6137 mark.hamzy 1.62 int s = s8.size ();
6138 jobjectArray jbyteA = (jobjectArray)jEnv->NewObjectArray (s,
6139 JMPIjvm::jv.ByteClassRef,
6140 0);
|
6141 mark.hamzy 1.20
|
6142 mark.hamzy 1.62 for (int i = 0; i < s; i++)
6143 jEnv->SetObjectArrayElement (jbyteA,
6144 i,
6145 jEnv->NewObject (JMPIjvm::jv.ByteClassRef,
6146 JMPIjvm::jv.ByteNewB,
6147 (jbyte)s8[i]));
6148 return jbyteA;
6149 }
6150 case CIMTYPE_UINT8:
6151 {
6152 Array<Uint8> u8;
|
6153 mark.hamzy 1.20
|
6154 mark.hamzy 1.62 cv->get (u8);
|
6155 mark.hamzy 1.20
|
6156 mark.hamzy 1.62 int s = u8.size ();
6157 jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray (s,
6158 JMPIjvm::jv.UnsignedInt8ClassRef,
6159 0);
6160 for (int i = 0; i < s; i++)
6161 jEnv->SetObjectArrayElement (jshortA,
6162 i,
6163 jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef,
6164 JMPIjvm::jv.UnsignedInt8NewS,
6165 (jshort)u8[i]));
6166 return jshortA;
6167 }
6168 case CIMTYPE_SINT16:
6169 {
6170 Array<Sint16> s16;
|
6171 mark.hamzy 1.20
|
6172 mark.hamzy 1.62 cv->get (s16);
|
6173 mark.hamzy 1.20
|
6174 mark.hamzy 1.62 int s = s16.size ();
6175 jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray (s,
6176 JMPIjvm::jv.ShortClassRef,
6177 0);
|
6178 schuur 1.3
|
6179 mark.hamzy 1.62 for (int i = 0; i < s; i++)
6180 jEnv->SetObjectArrayElement (jshortA,
6181 i,
6182 jEnv->NewObject (JMPIjvm::jv.ShortClassRef,
6183 JMPIjvm::jv.ShortNewS,
6184 (jshort)s16[i]));
6185 return jshortA;
6186 }
6187 case CIMTYPE_UINT16:
6188 {
6189 Array<Uint16> u16;
|
6190 mark.hamzy 1.44
|
6191 mark.hamzy 1.62 cv->get (u16);
|
6192 mark.hamzy 1.20
|
6193 mark.hamzy 1.62 int s = u16.size ();
6194 jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray (s,
6195 JMPIjvm::jv.UnsignedInt16ClassRef,
6196 0);
|
6197 schuur 1.3
|
6198 mark.hamzy 1.62 for (int i = 0; i < s; i++)
6199 jEnv->SetObjectArrayElement (jintA,
6200 i,
6201 jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef,
6202 JMPIjvm::jv.UnsignedInt16NewI,
6203 (jint)u16[i]));
6204 return jintA;
|
6205 mark.hamzy 1.44 }
|
6206 mark.hamzy 1.62 case CIMTYPE_SINT32:
|
6207 mark.hamzy 1.44 {
|
6208 mark.hamzy 1.62 Array<Sint32> s32;
6209
6210 cv->get (s32);
|
6211 mark.hamzy 1.20
|
6212 mark.hamzy 1.62 int s = s32.size ();
6213 jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray (s,
6214 JMPIjvm::jv.IntegerClassRef,
6215 0);
|
6216 mark.hamzy 1.20
|
6217 mark.hamzy 1.62 for (int i = 0; i < s; i++)
6218 jEnv->SetObjectArrayElement (jintA,
6219 i,
6220 jEnv->NewObject (JMPIjvm::jv.IntegerClassRef,
6221 JMPIjvm::jv.IntegerNewI,
6222 (jint)s32[i]));
6223 return jintA;
|
6224 mark.hamzy 1.44 }
|
6225 mark.hamzy 1.62 case CIMTYPE_UINT32:
6226 {
6227 Array<Uint32> u32;
|
6228 mark.hamzy 1.20
|
6229 mark.hamzy 1.62 cv->get (u32);
|
6230 mark.hamzy 1.20
|
6231 mark.hamzy 1.62 int s = u32.size ();
6232 jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray (s,
6233 JMPIjvm::jv.UnsignedInt32ClassRef,
6234 0);
|
6235 mark.hamzy 1.20
|
6236 mark.hamzy 1.62 for (int i = 0; i < s; i++)
6237 jEnv->SetObjectArrayElement (jlongA,
6238 i,
6239 jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef,
6240 JMPIjvm::jv.UnsignedInt32NewJ,
6241 (jlong)u32[i]));
6242 return jlongA;
|
6243 mark.hamzy 1.44 }
|
6244 mark.hamzy 1.62 case CIMTYPE_SINT64:
|
6245 mark.hamzy 1.44 {
|
6246 mark.hamzy 1.62 Array<Sint64> s64;
6247
6248 cv->get (s64);
|
6249 mark.hamzy 1.44
|
6250 mark.hamzy 1.62 int s = s64.size ();
6251 jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray (s,
6252 JMPIjvm::jv.LongClassRef,
6253 0);
|
6254 mark.hamzy 1.44
|
6255 mark.hamzy 1.62 for (int i = 0; i < s; i++)
6256 jEnv->SetObjectArrayElement (jlongA,
6257 i,
6258 jEnv->NewObject (JMPIjvm::jv.LongClassRef,
6259 JMPIjvm::jv.LongNewJ,
6260 (jlong)s64[i]));
6261 return jlongA;
|
6262 mark.hamzy 1.44 }
|
6263 mark.hamzy 1.62 case CIMTYPE_UINT64:
6264 {
6265 Array<Uint64> u64;
|
6266 mark.hamzy 1.44
|
6267 mark.hamzy 1.62 cv->get (u64);
|
6268 mark.hamzy 1.44
|
6269 mark.hamzy 1.62 int s = u64.size ();
6270 jobjectArray ju64A = (jobjectArray)jEnv->NewObjectArray (s,
6271 JMPIjvm::jv.UnsignedInt64ClassRef,
6272 0);
|
6273 mark.hamzy 1.44
|
6274 mark.hamzy 1.62 for (int i = 0; i < s; i++)
6275 {
6276 std::ostringstream oss;
6277 jstring jString = 0;
6278 jobject jBIG = 0;
|
6279 mark.hamzy 1.44
|
6280 mark.hamzy 1.62 oss << u64[i] << ends;
|
6281 mark.hamzy 1.44
|
6282 mark.hamzy 1.62 jString = jEnv->NewStringUTF (oss.str ().c_str ());
|
6283 mark.hamzy 1.44
|
6284 mark.hamzy 1.62 if (jString)
6285 {
6286 jBIG = jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,
6287 JMPIjvm::jv.UnsignedInt64NewStr,
6288 jString);
6289 }
|
6290 mark.hamzy 1.44
|
6291 mark.hamzy 1.62 if (jBIG)
6292 {
6293 jEnv->SetObjectArrayElement (ju64A,
6294 i,
6295 jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,
6296 JMPIjvm::jv.UnsignedInt64NewBi,
6297 jBIG));
6298 }
6299 }
6300 return ju64A;
6301 }
6302 case CIMTYPE_REAL32:
6303 {
6304 Array<Real32> r32;
|
6305 schuur 1.3
|
6306 mark.hamzy 1.62 cv->get (r32);
|
6307 mark.hamzy 1.44
|
6308 mark.hamzy 1.62 int s = r32.size ();
6309 jobjectArray jfloatA = (jobjectArray)jEnv->NewObjectArray (s,
6310 JMPIjvm::jv.FloatClassRef,
6311 0);
|
6312 mark.hamzy 1.44
|
6313 mark.hamzy 1.62 for (int i = 0; i < s; i++)
6314 jEnv->SetObjectArrayElement (jfloatA,
6315 i,
6316 jEnv->NewObject (JMPIjvm::jv.FloatClassRef,
6317 JMPIjvm::jv.FloatNewF,
6318 (jfloat)r32[i]));
6319 return jfloatA;
6320 }
6321 case CIMTYPE_REAL64:
|
6322 mark.hamzy 1.44 {
|
6323 mark.hamzy 1.62 Array<Real64> r64;
|
6324 mark.hamzy 1.44
|
6325 mark.hamzy 1.62 cv->get (r64);
|
6326 mark.hamzy 1.20
|
6327 mark.hamzy 1.62 int s = r64.size ();
6328 jobjectArray jdoubleA = (jobjectArray)jEnv->NewObjectArray (s,
6329 JMPIjvm::jv.DoubleClassRef,
6330 0);
|
6331 schuur 1.3
|
6332 mark.hamzy 1.62 for (int i = 0; i < s; i++)
6333 jEnv->SetObjectArrayElement (jdoubleA,
6334 i,
6335 jEnv->NewObject (JMPIjvm::jv.DoubleClassRef,
6336 JMPIjvm::jv.DoubleNewD,
6337 (jdouble)r64[i]));
6338 return jdoubleA;
|
6339 mark.hamzy 1.44 }
|
6340 mark.hamzy 1.62 case CIMTYPE_STRING:
|
6341 mark.hamzy 1.44 {
|
6342 mark.hamzy 1.62 Array<String> str;
6343
6344 cv->get (str);
|
6345 mark.hamzy 1.44
|
6346 mark.hamzy 1.62 int s = str.size ();
6347 jobjectArray jstringA = (jobjectArray)jEnv->NewObjectArray (s,
6348 JMPIjvm::jv.StringClassRef,
6349 0);
|
6350 mark.hamzy 1.44
|
6351 mark.hamzy 1.62 for (int i = 0; i < s; i++)
6352 jEnv->SetObjectArrayElement (jstringA,
6353 i,
6354 jEnv->NewStringUTF (str[i].getCString ()));
6355 return jstringA;
|
6356 mark.hamzy 1.44 }
|
6357 mark.hamzy 1.62 case CIMTYPE_REFERENCE:
6358 {
6359 Array<CIMObjectPath> ref;
|
6360 mark.hamzy 1.44
|
6361 mark.hamzy 1.62 cv->get (ref);
|
6362 schuur 1.3
|
6363 mark.hamzy 1.62 int s = ref.size ();
6364 jobjectArray jrefA = (jobjectArray)jEnv->NewObjectArray (s,
6365 JMPIjvm::jv.CIMObjectPathClassRef,
6366 0);
|
6367 mark.hamzy 1.20
|
6368 mark.hamzy 1.62 for (int i = 0; i < s; i++)
6369 {
6370 jlong jOP = DEBUG_ConvertCToJava (CIMObjectPath*, jlong, new CIMObjectPath (ref[i]));
|
6371 mark.hamzy 1.20
|
6372 mark.hamzy 1.62 jEnv->SetObjectArrayElement (jrefA,
6373 i,
6374 jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef,
6375 JMPIjvm::jv.CIMObjectPathNewJ,
6376 jOP));
6377 }
6378 return jrefA;
6379 }
6380 case CIMTYPE_CHAR16:
6381 {
6382 Array<Char16> c16;
|
6383 schuur 1.3
|
6384 mark.hamzy 1.62 cv->get (c16);
|
6385 mark.hamzy 1.44
|
6386 mark.hamzy 1.62 int s = c16.size ();
6387 jobjectArray jc16A = (jobjectArray)jEnv->NewObjectArray (s,
6388 JMPIjvm::jv.CharacterClassRef,
6389 0);
|
6390 mark.hamzy 1.44
|
6391 mark.hamzy 1.62 for (int i = 0; i < s; i++)
6392 jEnv->SetObjectArrayElement (jc16A,
6393 i,
6394 jEnv->NewObject (JMPIjvm::jv.CharacterClassRef,
6395 JMPIjvm::jv.CharacterNewC,
6396 (jchar)c16[i]));
|
6397 mark.hamzy 1.44
|
6398 mark.hamzy 1.62 return jc16A;
|
6399 mark.hamzy 1.44 }
|
6400 mark.hamzy 1.62 case CIMTYPE_DATETIME:
|
6401 mark.hamzy 1.44 {
|
6402 mark.hamzy 1.62 Array<CIMDateTime> dt;
6403
6404 cv->get (dt);
6405
6406 int s = dt.size ();
6407 jobjectArray jdtA = (jobjectArray)jEnv->NewObjectArray (s,
6408 JMPIjvm::jv.CIMDateTimeClassRef,
6409 0);
|
6410 mark.hamzy 1.44
|
6411 mark.hamzy 1.62 for (int i = 0; i < s; i++)
6412 {
6413 jlong jDT = DEBUG_ConvertCToJava (CIMDateTime*, jlong, new CIMDateTime (dt[i]));
|
6414 mark.hamzy 1.44
|
6415 mark.hamzy 1.62 jEnv->SetObjectArrayElement (jdtA,
6416 i,
6417 jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef,
6418 JMPIjvm::jv.CIMDateTimeNewJ,
6419 jDT));
6420 }
6421 return jdtA;
|
6422 mark.hamzy 1.44 }
|
6423 mark.hamzy 1.62 case CIMTYPE_OBJECT:
6424 {
6425 Array<CIMObject> co;
|
6426 schuur 1.3
|
6427 mark.hamzy 1.62 cv->get (co);
|
6428 mark.hamzy 1.20
|
6429 mark.hamzy 1.62 int s = co.size ();
6430 jobjectArray jcoA = (jobjectArray)jEnv->NewObjectArray (s,
6431 JMPIjvm::jv.CIMObjectClassRef,
6432 0);
|
6433 mark.hamzy 1.20
|
6434 mark.hamzy 1.62 for (int i = 0; i < s; i++)
6435 {
6436 if (co[i].isClass ())
6437 {
6438 jlong jCC = DEBUG_ConvertCToJava (CIMClass*, jlong, new CIMClass (co[i]));
|
6439 schuur 1.3
|
6440 mark.hamzy 1.62 jEnv->SetObjectArrayElement (jcoA,
6441 i,
6442 jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,
6443 JMPIjvm::jv.CIMObjectNewJZ,
6444 jCC,
6445 (jboolean)true));
6446 }
6447 else
6448 {
6449 jlong jCI = DEBUG_ConvertCToJava (CIMInstance*, jlong, new CIMInstance (co[i]));
|
6450 mark.hamzy 1.56
|
6451 mark.hamzy 1.62 jEnv->SetObjectArrayElement (jcoA,
6452 i,
6453 jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,
6454 JMPIjvm::jv.CIMObjectNewJZ,
6455 jCI,
6456 (jboolean)false));
6457 }
6458 }
6459 return jcoA;
6460 }
6461 default:
6462 throwCIMException (jEnv,"+++ unsupported type: ");
|
6463 schuur 1.3 }
6464 }
|
6465 mark.hamzy 1.20
|
6466 mark.hamzy 1.62 return NULL;
|
6467 schuur 1.5 }
6468
|
6469 mark.hamzy 1.62 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType
6470 (JNIEnv *jEnv, jobject jThs, jlong jP)
|
6471 mark.hamzy 1.44 {
|
6472 mark.hamzy 1.62 CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jP);
6473 bool fSuccess = false;
|
6474 mark.hamzy 1.63 jint jiJType = 0;
|
6475 mark.hamzy 1.62
|
6476 mark.hamzy 1.63 jiJType = _dataType::convertCTypeToJavaType (cv->getType (), &fSuccess);
|
6477 mark.hamzy 1.56
|
6478 mark.hamzy 1.63 return jiJType;
|
6479 mark.hamzy 1.62 }
|
6480 schuur 1.6
|
6481 mark.hamzy 1.62 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMValue__1isArray
6482 (JNIEnv *jEnv, jobject jThs, jlong jP)
6483 {
6484 CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jP);
|
6485 mark.hamzy 1.44
|
6486 mark.hamzy 1.62 return (jboolean)cv->isArray ();
6487 }
|
6488 mark.hamzy 1.56
|
6489 mark.hamzy 1.62 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString
6490 (JNIEnv *jEnv, jobject jThs, jlong jV)
6491 {
6492 CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);
|
6493 mark.hamzy 1.56
|
6494 mark.hamzy 1.62 return (jstring)jEnv->NewStringUTF (cv->toString ().getCString ());
|
6495 schuur 1.6 }
6496
|
6497 mark.hamzy 1.62 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMValue__1finalize
6498 (JNIEnv *jEnv, jobject jThs, jlong jV)
|
6499 mark.hamzy 1.20 {
|
6500 mark.hamzy 1.62 CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);
6501
6502 delete cv;
|
6503 schuur 1.5
|
6504 mark.hamzy 1.62 DEBUG_ConvertCleanup (jlong, jV);
6505 }
|
6506 schuur 1.6
6507
|
6508 mark.hamzy 1.62 // -------------------------------------
6509 // ---
6510 // - ClassEnumeration
6511 // ---
6512 // -------------------------------------
|
6513 schuur 1.5
|
6514 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1getClass
6515 (JNIEnv *jEnv, jobject jThs, jlong jEnum, jint pos)
6516 {
6517 Array<CIMClass> *enm = DEBUG_ConvertJavaToC (jlong, Array<CIMClass>*, jEnum);
|
6518 schuur 1.5
|
6519 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMClass*, jlong, new CIMClass ((*enm)[pos]));
|
6520 schuur 1.5 }
6521
|
6522 mark.hamzy 1.62 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1size
6523 (JNIEnv *jEnv, jobject jThs, jlong jEnum)
|
6524 mark.hamzy 1.20 {
|
6525 mark.hamzy 1.62 Array<CIMClass> *enm = DEBUG_ConvertJavaToC (jlong, Array<CIMClass>*, jEnum);
|
6526 mark.hamzy 1.30
|
6527 mark.hamzy 1.62 return enm->size ();
6528 }
|
6529 schuur 1.6
|
6530 mark.hamzy 1.56
|
6531 mark.hamzy 1.62 // -------------------------------------
6532 // ---
6533 // - InstEnumeration
6534 // ---
6535 // -------------------------------------
|
6536 mark.hamzy 1.56
|
6537 mark.hamzy 1.62 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_InstEnumeration__1getInstance
6538 (JNIEnv *jEnv, jobject jThs, jlong jEnum, jint pos)
6539 {
6540 Array<CIMInstance> *enm = DEBUG_ConvertJavaToC (jlong, Array<CIMInstance>*, jEnum);
|
6541 mark.hamzy 1.56
|
6542 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMInstance*, jlong, new CIMInstance ((*enm)[pos]));
|
6543 schuur 1.5 }
6544
|
6545 mark.hamzy 1.62 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1size
6546 (JNIEnv *jEnv, jobject jThs, jlong jEnum)
|
6547 mark.hamzy 1.20 {
|
6548 mark.hamzy 1.62 Array<CIMInstance> *enm = DEBUG_ConvertJavaToC (jlong, Array<CIMInstance>*, jEnum);
|
6549 schuur 1.6
|
6550 mark.hamzy 1.62 return enm->size ();
6551 }
|
6552 mark.hamzy 1.20
|
6553 mark.hamzy 1.62 // -------------------------------------
6554 // ---
6555 // - JMPIQueryExp
6556 // ---
6557 // -------------------------------------
|
6558 schuur 1.6
|
6559 mark.hamzy 1.62 /*
6560 * Class: org_pegasus_jmpi_JMPIQueryExp
6561 * Method: _applyInstance
6562 * Signature: (II)Z
6563 */
6564 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_JMPIQueryExp__1applyInstance
6565 (JNIEnv *jEnv, jobject jThs, jlong jWQLStmt, jlong jciInstance)
6566 {
6567 WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jlong, WQLSelectStatement*, jWQLStmt);
6568 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciInstance);
|
6569 schuur 1.6
|
6570 mark.hamzy 1.62 if ( !wql_stmt
6571 || !ci
6572 )
6573 {
6574 return 0;
6575 }
|
6576 mark.hamzy 1.56
|
6577 mark.hamzy 1.62 try
6578 {
6579 return wql_stmt->evaluate (*ci);
|
6580 schuur 1.6 }
|
6581 mark.hamzy 1.62 catch (const Exception &e)
6582 {
6583 cerr << "Java_org_pegasus_jmpi_JMPIQueryExp__1applyInstance: Caught: " << e.getMessage () << endl;
|
6584 mark.hamzy 1.24
|
6585 mark.hamzy 1.62 return false;
6586 }
|
6587 mark.hamzy 1.24 }
6588
|
6589 mark.hamzy 1.62
|
6590 mark.hamzy 1.38 // -------------------------------------
6591 // ---
|
6592 mark.hamzy 1.62 // - JMPISelectList
|
6593 mark.hamzy 1.38 // ---
6594 // -------------------------------------
6595
|
6596 mark.hamzy 1.62 /*
6597 * Class: org_pegasus_jmpi_JMPISelectList
6598 * Method: _applyInstance
6599 * Signature: (II)I
6600 */
6601 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyInstance
6602 (JNIEnv *jEnv, jobject jThs, jlong jWQLStmt, jlong jciInstance)
|
6603 mark.hamzy 1.35 {
|
6604 mark.hamzy 1.62 WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jlong, WQLSelectStatement*, jWQLStmt);
6605 CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciInstance);
6606 CIMInstance *ciRet = 0;
6607
6608 if ( !wql_stmt
6609 || !ci
6610 )
6611 {
6612 return 0;
6613 }
6614
6615 ciRet = new CIMInstance (ci->clone ());
|
6616 mark.hamzy 1.35
|
6617 mark.hamzy 1.62 if (ciRet)
6618 {
6619 try
6620 {
6621 wql_stmt->applyProjection (*ciRet, false);
6622 }
6623 catch (const Exception &e)
6624 {
6625 cerr << "Java_org_pegasus_jmpi_JMPISelectList__1applyInstance: Caught: " << e.getMessage () << endl;
|
6626 mark.hamzy 1.35
|
6627 mark.hamzy 1.62 return 0;
6628 }
|
6629 mark.hamzy 1.35 }
6630
|
6631 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMInstance *, jlong, ciRet);
|
6632 mark.hamzy 1.35 }
6633
|
6634 mark.hamzy 1.62 /*
6635 * Class: org_pegasus_jmpi_JMPISelectList
6636 * Method: _applyClass
6637 * Signature: (II)I
6638 */
6639 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyClass
6640 (JNIEnv *jEnv, jobject jThs, jlong jWQLStmt, jlong jciClass)
|
6641 mark.hamzy 1.35 {
|
6642 mark.hamzy 1.62 WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jlong, WQLSelectStatement*, jWQLStmt);
6643 CIMClass *cc = DEBUG_ConvertJavaToC (jlong, CIMClass*, jciClass);
6644 CIMClass *ccRet = NULL;
6645
6646 if (!wql_stmt)
6647 {
6648 return 0;
6649 }
6650
6651 if (cc)
6652 {
6653 CIMObject co (cc->clone ());
6654
6655 try
6656 {
6657 wql_stmt->applyProjection (co, false);
6658 }
6659 catch (const Exception &e)
6660 {
6661 cerr << "Java_org_pegasus_jmpi_JMPISelectList__1applyClass: Caught: " << e.getMessage () << endl;
6662
6663 mark.hamzy 1.62 return 0;
6664 }
|
6665 mark.hamzy 1.35
|
6666 mark.hamzy 1.62 ccRet = new CIMClass (co);
|
6667 mark.hamzy 1.35
|
6668 mark.hamzy 1.62 return DEBUG_ConvertCToJava (CIMClass *, jlong, ccRet);
|
6669 mark.hamzy 1.35 }
6670
6671 return 0;
6672 }
6673
6674
|
6675 mark.hamzy 1.38 // -------------------------------------
6676 // ---
6677 // - OperationContext
6678 // ---
6679 // -------------------------------------
6680
|
6681 mark.hamzy 1.36 /*
6682 * Class: OperationContext
6683 * Method: _get
6684 * Signature: (ILjava/lang/String;Ljava/lang/String;)Ljava/lang/Object;
6685 */
6686 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_OperationContext__1get
|
6687 mark.hamzy 1.61 (JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jContainer, jstring jKey)
|
6688 mark.hamzy 1.36 {
|
6689 mark.hamzy 1.61 OperationContext *poc = DEBUG_ConvertJavaToC (jlong, OperationContext*, jInst);
|
6690 mark.hamzy 1.36 jobject jRet = 0;
6691
6692 if (!poc)
6693 {
6694 return jRet;
6695 }
6696
6697 const char *pszContainer = jEnv->GetStringUTFChars (jContainer, NULL);
6698 const char *pszKey = jEnv->GetStringUTFChars (jKey, NULL);
6699 String container (pszContainer);
6700 String key (pszKey);
6701
6702 ///printf ("container: %s\n", pszContainer);
6703 ///printf ("key: %s\n", pszKey);
6704
6705 try {
6706 if (container == "IdentityContainer")
6707 {
6708 IdentityContainer ic = poc->get (IdentityContainer::NAME);
6709
6710 /////////printf ("ic\n");
6711 mark.hamzy 1.36
6712 if (key == "userName")
6713 {
6714 String userName = ic.getUserName ();
6715
6716 ////////////printf ("userName: %s\n", (const char*)userName.getCString ());
6717
6718 jRet = jEnv->NewStringUTF ((const char*)userName.getCString ());
6719 }
6720 }
6721 else if (container == "SubscriptionInstanceContainer")
6722 {
6723 SubscriptionInstanceContainer sic = poc->get (SubscriptionInstanceContainer::NAME);
6724
6725 if (key == "subscriptionInstance")
6726 {
6727 CIMInstance ci = sic.getInstance ();
|
6728 mark.hamzy 1.61 jlong jciRef = DEBUG_ConvertCToJava (CIMInstance*, jlong, new CIMInstance (ci));
|
6729 mark.hamzy 1.36
6730 jRet = jEnv->NewObject (JMPIjvm::jv.CIMInstanceClassRef,
|
6731 mark.hamzy 1.61 JMPIjvm::jv.CIMInstanceNewJ,
|
6732 mark.hamzy 1.36 jciRef);
6733 }
6734 }
6735 else if (container == "SubscriptionInstanceNamesContainer")
6736 {
6737 SubscriptionInstanceNamesContainer sinc = poc->get (SubscriptionInstanceNamesContainer::NAME);
6738
6739 if (key == "subscriptionInstanceNames")
6740 {
6741 Array<CIMObjectPath> copa = sinc.getInstanceNames ();
6742 jobjectArray jcopa = 0;
6743 int jcopaLength = copa.size ();
6744
|
6745 mark.hamzy 1.48 jcopa = (jobjectArray)jEnv->NewObjectArray (jcopaLength,
6746 JMPIjvm::jv.CIMObjectPathClassRef,
6747 0);
|
6748 mark.hamzy 1.36
6749 for (int i = 0; i < jcopaLength; i++)
6750 {
6751 jEnv->SetObjectArrayElement (jcopa,
6752 i,
6753 jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef,
|
6754 mark.hamzy 1.61 JMPIjvm::jv.CIMObjectPathNewJ,
|
6755 mark.hamzy 1.36 new CIMObjectPath (copa[i])));
6756 }
6757
6758 jRet = (jobject)jcopa;
6759 }
6760 }
6761 else if (container == "SubscriptionFilterConditionContainer")
6762 {
6763 SubscriptionFilterConditionContainer sfcc = poc->get (SubscriptionFilterConditionContainer::NAME);
6764
6765 /////////printf ("sfcc\n");
6766
6767 if (key == "filterCondition")
6768 {
6769 String filterCondition = sfcc.getFilterCondition ();
6770
6771 ////////////printf ("filterCondition: %s\n", (const char*)filterCondition.getCString ());
6772
6773 jRet = jEnv->NewStringUTF ((const char*)filterCondition.getCString ());
6774 }
6775 else if (key == "queryLanguage")
6776 mark.hamzy 1.36 {
6777 String queryLanguage = sfcc.getQueryLanguage ();
6778
6779 jRet = jEnv->NewStringUTF ((const char*)queryLanguage.getCString ());
6780 }
6781 }
6782 else if (container == "SubscriptionFilterQueryContainer")
6783 {
6784 SubscriptionFilterQueryContainer sfqc = poc->get (SubscriptionFilterQueryContainer::NAME);
6785
6786 if (key == "filterQuery")
6787 {
6788 String filterQuery = sfqc.getFilterQuery ();
6789
6790 jRet = jEnv->NewStringUTF ((const char*)filterQuery.getCString ());
6791 }
6792 else if (key == "queryLanguage")
6793 {
6794 String queryLanguage = sfqc.getQueryLanguage ();
6795
6796 jRet = jEnv->NewStringUTF ((const char*)queryLanguage.getCString ());
6797 mark.hamzy 1.36 }
6798 else if (key == "sourceNameSpace")
6799 {
6800 CIMNamespaceName cimNameSpaceName = sfqc.getSourceNameSpace ();
6801 String nameSpaceName = cimNameSpaceName.getString ();
6802
6803 jRet = jEnv->NewStringUTF ((const char*)nameSpaceName.getCString ());
6804 }
6805 }
6806 else if (container == "SnmpTrapOidContainer")
6807 {
6808 SnmpTrapOidContainer stoc = poc->get (SnmpTrapOidContainer::NAME);
6809
6810 if (key == "snmpTrapOid")
6811 {
6812 String snmpTrapOid = stoc.getSnmpTrapOid ();
6813
6814 jRet = jEnv->NewStringUTF ((const char*)snmpTrapOid.getCString ());
6815 }
6816 }
6817 }
|
6818 mark.hamzy 1.44 Catch (jEnv);
|
6819 mark.hamzy 1.36
6820 ///printf ("jRet: %08X\n", (int)jRet);
6821
6822 jEnv->ReleaseStringUTFChars (jContainer, pszContainer);
6823 jEnv->ReleaseStringUTFChars (jKey, pszKey);
6824
6825 return jRet;
6826 }
6827
|
6828 mark.hamzy 1.62
6829 // -------------------------------------
6830 // ---
6831 // - PathEnumeration
6832 // ---
6833 // -------------------------------------
6834
6835 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_PathEnumeration__1getObjectPath
6836 (JNIEnv *jEnv, jobject jThs, jlong jEnum, jint pos)
6837 {
6838 Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC (jlong, Array<CIMObjectPath>*, jEnum);
6839
6840 return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, new CIMObjectPath ((*enm)[pos]));
6841 }
6842
6843 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1size
6844 (JNIEnv *jEnv, jobject jThs, jlong jEnum)
6845 {
6846 Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC (jlong, Array<CIMObjectPath>*, jEnum);
6847
6848 return enm->size ();
6849 mark.hamzy 1.62 }
6850
6851
6852 // -------------------------------------
6853 // ---
6854 // - QualEnumeration
6855 // ---
6856 // -------------------------------------
6857
6858 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_QualEnumeration__1getQualifierType
6859 (JNIEnv *jEnv, jobject jThs, jlong jEnum, jint pos)
6860 {
6861 Array<CIMQualifierDecl> *enm = DEBUG_ConvertJavaToC (jlong, Array<CIMQualifierDecl>*, jEnum);
6862
6863 return DEBUG_ConvertCToJava (CIMQualifierDecl*, jlong, new CIMQualifierDecl ((*enm)[pos]));
6864 }
6865
6866 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1size
6867 (JNIEnv *jEnv, jobject jThs, jlong jEnum)
6868 {
6869 Array<CIMQualifierDecl> *enm = DEBUG_ConvertJavaToC (jlong, Array<CIMQualifierDecl>*, jEnum);
6870 mark.hamzy 1.62
6871 return enm->size ();
6872 }
6873
6874
|
6875 mark.hamzy 1.38 // -------------------------------------
6876 // ---
6877 // - SelectExp
6878 // ---
6879 // -------------------------------------
6880
6881 /*
6882 * Class: org_pegasus_jmpi_SelectExp
6883 * Method: _finalize
6884 * Signature: (I)V
6885 */
6886 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_SelectExp__1finalize
|
6887 mark.hamzy 1.61 (JNIEnv *jEnv, jobject jThs, jlong jWQLStmt)
|
6888 mark.hamzy 1.38 {
|
6889 mark.hamzy 1.61 WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jlong, WQLSelectStatement*, jWQLStmt);
|
6890 mark.hamzy 1.38
|
6891 mark.hamzy 1.42 delete wql_stmt;
|
6892 mark.hamzy 1.38
|
6893 mark.hamzy 1.61 DEBUG_ConvertCleanup (jlong, jWQLStmt);
|
6894 mark.hamzy 1.38 }
6895
6896 /*
6897 * Class: org_pegasus_jmpi_SelectExp
6898 * Method: _newSelectExp
6899 * Signature: (Ljava/lang/String;)I
6900 */
|
6901 mark.hamzy 1.61 JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_SelectExp__1newSelectExp
|
6902 mark.hamzy 1.38 (JNIEnv *jEnv, jobject jThs, jstring jQuery)
6903 {
6904 const char *pszQuery = jEnv->GetStringUTFChars (jQuery, NULL);
|
6905 mark.hamzy 1.42 WQLSelectStatement *wql_stmt = NULL;
|
6906 mark.hamzy 1.38 String queryLanguage (CALL_SIGN_WQL);
6907 String query (pszQuery);
6908
|
6909 mark.hamzy 1.42 wql_stmt = new WQLSelectStatement (queryLanguage, query);
|
6910 mark.hamzy 1.61 DDD (PEGASUS_STD (cout)<<"--- Java_org_pegasus_jmpi_SelectExp__1newSelectExp: wql_stmt = "<<PEGASUS_STD (hex)<< (long)wql_stmt<<PEGASUS_STD (dec)<<PEGASUS_STD (endl));
|
6911 mark.hamzy 1.42
6912 try
6913 {
6914 WQLParser::parse (query, *wql_stmt);
6915 }
6916 catch (const Exception &e)
6917 {
6918 cerr << "Java_org_pegasus_jmpi_SelectExp__1newSelectExp: Caught: " << e.getMessage () << endl;
6919 }
|
6920 mark.hamzy 1.38
6921 jEnv->ReleaseStringUTFChars (jQuery, pszQuery);
6922
|
6923 mark.hamzy 1.61 return DEBUG_ConvertCToJava (WQLSelectStatement *, jlong, wql_stmt);
|
6924 mark.hamzy 1.38 }
6925
6926 /*
6927 * Class: org_pegasus_jmpi_SelectExp
6928 * Method: _getSelectString
6929 * Signature: (I)Ljava/lang/String;
6930 */
6931 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_SelectExp__1getSelectString
|
6932 mark.hamzy 1.61 (JNIEnv *jEnv, jobject jThs, jlong jWQLStmt)
|
6933 mark.hamzy 1.38 {
|
6934 mark.hamzy 1.61 WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jlong, WQLSelectStatement*, jWQLStmt);
|
6935 mark.hamzy 1.42 String cond;
6936
6937 if (wql_stmt)
6938 {
6939 try
6940 {
6941 cond = wql_stmt->getQuery ();
6942 }
6943 catch (const Exception &e)
6944 {
6945 cerr << "Java_org_pegasus_jmpi_SelectExp__1getSelectString: Caught: " << e.getMessage () << endl;
6946
6947 cond = "";
6948 }
6949 }
6950 else
6951 {
6952 cond = "";
6953 }
|
6954 mark.hamzy 1.38
|
6955 mark.hamzy 1.42 return (jstring)jEnv->NewStringUTF (cond.getCString ());
|
6956 mark.hamzy 1.38 }
6957
|
6958 schuur 1.5 } // extern "C"
|
6959 schuur 1.1
6960 PEGASUS_NAMESPACE_END
|
Return to
JMPIImpl.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI