1 karl 1.12 //%2005////////////////////////////////////////////////////////////////////////
|
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 schuur 1.1 //
12 // Permission is hereby granted, free of charge, to any person obtaining a copy
13 // of this software and associated documentation files (the "Software"), to
14 // deal in the Software without restriction, including without limitation the
15 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
16 // sell copies of the Software, and to permit persons to whom the Software is
17 // furnished to do so, subject to the following conditions:
|
18 david.dillard 1.15 //
|
19 schuur 1.1 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
20 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
21 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
22 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
23 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
24 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
25 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 //
28 //==============================================================================
29 //
30 // Author: Adrian Schuur, schuur@de.ibm.com
31 //
32 // Modified By: Adrian Dutta
33 // Andy Viciu
34 // Magda Vacarelu
|
35 david.dillard 1.15 // David Dillard, VERITAS Software Corp.
36 // (david.dillard@veritas.com)
|
37 mark.hamzy 1.24 // Mark Hamzy, hamzy@us.ibm.com
|
38 schuur 1.1 //
39 //%/////////////////////////////////////////////////////////////////////////////
40
41
42 #include "JMPIImpl.h"
43
|
44 konrad.r 1.14 #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)
45 #include <Pegasus/Common/DynamicLibrary.h>
46 #else
|
47 schuur 1.1 #include <dlfcn.h>
|
48 konrad.r 1.14 #endif
|
49 schuur 1.1 #include <iostream>
|
50 mark.hamzy 1.16 #include <sstream>
|
51 schuur 1.1
52 #include <Pegasus/Common/Config.h>
53 #include <Pegasus/Common/System.h>
54 #include <Pegasus/Common/CIMClass.h>
55 #include <Pegasus/Common/CIMInstance.h>
56 #include <Pegasus/Common/CIMObjectPath.h>
57 #include <Pegasus/Common/CIMProperty.h>
58 #include <Pegasus/Common/CIMType.h>
59 #include <Pegasus/Common/OperationContext.h>
60 #include <Pegasus/Provider/CIMOMHandle.h>
61 #include <Pegasus/Client/CIMClient.h>
|
62 schuur 1.3 #include <Pegasus/ProviderManager2/JMPI/JMPIProviderManager.h>
|
63 schuur 1.1
64 PEGASUS_USING_STD;
65 PEGASUS_NAMESPACE_BEGIN
66
67 JavaVM *JMPIjvm::jvm=NULL;
68 JvmVector JMPIjvm::jv;
|
69 schuur 1.2 int JMPIjvm::trace=0;
|
70 schuur 1.1
|
71 mark.hamzy 1.16 #define DDD(x) if (JMPIjvm::trace) x;
72
|
73 mark.hamzy 1.20 #include "Convert.h"
74
|
75 mark.hamzy 1.17 JMPIjvm::ClassTable JMPIjvm::_classTable;
76 JMPIjvm::ObjectTable JMPIjvm::_objectTable;
77
|
78 schuur 1.1 typedef struct {
79 int clsIndex;
80 const char * methodName;
81 const char * signature;
82 } METHOD_STRUCT;
83
84 const char* classNames[]={
85 "java/util/Vector" , // 0
86 "java/lang/Boolean", // 1
87 "java/lang/Byte", // 2
88 "java/lang/Short", // 3
89 "java/lang/Integer", // 4
90 "java/lang/Long", // 5
91 "java/lang/Float", // 6
92 "java/lang/Double", // 7
93 "org/pegasus/jmpi/UnsignedInt8", // 8
94 "org/pegasus/jmpi/UnsignedInt16", // 9
95 "org/pegasus/jmpi/UnsignedInt32", // 10
96 "org/pegasus/jmpi/UnsignedInt64", // 11
97 "org/pegasus/jmpi/CIMObjectPath", // 12
98 "org/pegasus/jmpi/CIMException", // 13
99 schuur 1.1 "java/math/BigInteger", // 14
100 "org/pegasus/jmpi/CIMProperty", // 15
101
102 "org/pegasus/jmpi/CIMOMHandle", // 16
103 "org/pegasus/jmpi/CIMClass", // 17
104 "org/pegasus/jmpi/CIMInstance", // 18
105 "org/pegasus/jmpi/CIMValue", // 19
|
106 schuur 1.3 "java/lang/Object", // 20
107 "java/lang/Throwable", // 21
108 "java/lang/String", // 22
|
109 schuur 1.1 "org/pegasus/jmpi/JarClassLoader", // 23
|
110 schuur 1.3 "org/pegasus/jmpi/CIMDateTime", // 24
111 "org/pegasus/jmpi/SelectExp", // 25
|
112 schuur 1.5 "org/pegasus/jmpi/CIMQualifier", // 26
113 "org/pegasus/jmpi/CIMQualifierType",// 27
114 "org/pegasus/jmpi/CIMFlavor", // 28
|
115 schuur 1.7 "org/pegasus/jmpi/CIMArgument", // 29
116 "org/pegasus/jmpi/CIMInstanceException", // 30
|
117 schuur 1.1 };
118
119
120 const METHOD_STRUCT instanceMethodNames[]={
|
121 schuur 1.3 /*00*/ { 0, "<init>", "()V" },
|
122 schuur 1.1 /*01*/ { 1, "<init>", "(Z)V" },
123 /*02*/ { 2, "<init>", "(B)V" },
124 /*03*/ { 3, "<init>", "(S)V" },
125 /*04*/ { 4, "<init>", "(I)V" },
126 /*05*/ { 5, "<init>", "(J)V" }, // ???
127 /*06*/ { 6, "<init>", "(F)V" },
128 /*07*/ { 7, "<init>", "(D)V" },
129 /*08*/ { 8, "<init>", "(S)V" },
130 /*09*/ { 9, "<init>", "(I)V" },
131 /*10*/ { 10,"<init>", "(J)V" },
132 /*11*/ { 11,"<init>", "(Ljava/math/BigInteger;)V" },
133 /*12*/ { 12,"<init>", "(I)V" },
134 /*13*/ { 13,"<init>", "(Ljava/lang/String;)V" },
135 /*14*/ { 15,"<init>", "(I)V" },
136 /*15*/ { 0, "addElement", "(Ljava/lang/Object;)V" },
137
138 /*16*/ { 0, "elementAt", "(I)Ljava/lang/Object;" },
|
139 schuur 1.3 /*17*/ { 16,"<init>", "(ILjava/lang/String;)V" },
|
140 schuur 1.1 /*18*/ { 13,"<init>", "(I)V" },
141 /*19*/ { 17,"<init>", "(I)V" },
142 /*20*/ { 18,"<init>", "(I)V" },
143 /*21*/ { 12,"<init>", "(I)V" },
144 /*22*/ { 12,"cInst", "()I" },
145 /*23*/ { 18,"cInst", "()I" },
146 /*24*/ { 17,"cInst", "()I" },
147 /*25*/ { 20,"toString", "()Ljava/lang/String;" },
148 /*26*/ { 21,"getMessage", "()Ljava/lang/String;" },
149 /*27*/ { 13,"getID", "()Ljava/lang/String;" },
150 /*28*/ { 0, "size", "()I" },
151 /*29*/ { 15,"cInst", "()I" },
152 /*30*/ { 16,"getClass", "(Lorg/pegasus/jmpi/CIMObjectPath;Z)Lorg/pegasus/jmpi/CIMClass;" },
153 /*31*/ { 0, "removeElementAt", "(I)V" },
154 /*32*/ { 19,"cInst", "()I" },
|
155 schuur 1.7 /*33*/ { 13,"<init>", "(ILjava/lang/String;)V" },
156 /*34*/ { 13,"getCode", "()I" },
|
157 r.kieninger 1.11 /*35*/ { 24,"<init>", "(I)V" },
|
158 schuur 1.7 /*36*/ { 25,"<init>", "(I)V" },
159 /*37*/ { 26,"<init>", "(I)V" },
160 /*38*/ { 28,"<init>", "(I)V" },
161 /*38*/ { 28,"getFlavor", "()I" },
162 /*39*/ { 29,"cInst", "()I" },
163 /*40*/ { 29,"<init>", "(I)V" },
164 /*41*/ { 13,"<init>", "()V" },
165 /*42*/ { 13,"<init>", "(Ljava/lang/String;)V" },
166 /*43*/ { 13,"<init>", "(Ljava/lang/String;Ljava/lang/Object;)V" },
167 /*44*/ { 13,"<init>", "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)V" },
168 /*45*/ { 13,"<init>", "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V" },
|
169 mark.hamzy 1.23 /*47*/ { 19,"<init>", "(I)V" },
|
170 schuur 1.1 };
171
172 const METHOD_STRUCT staticMethodNames[]={
173 { 14, "valueOf", "(J)Ljava/math/BigInteger;" },
174 { 23, "load", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Class;" },
175 };
176
177
178 static int methodInitDone=0;
179
180 jclass classRefs[sizeof(classNames)/sizeof(char*)];
181 jmethodID instanceMethodIDs[sizeof(instanceMethodNames)/sizeof(METHOD_STRUCT)];
182 jmethodID staticMethodIDs[sizeof(staticMethodNames)/sizeof(METHOD_STRUCT)];
|
183 mark.hamzy 1.20
184 //static jclass providerClassRef;
|
185 schuur 1.1
186 jclass JMPIjvm::getGlobalClassRef(JNIEnv *env, const char* name) {
187 jclass localRefCls=env->FindClass(name);
|
188 mark.hamzy 1.16
|
189 mark.hamzy 1.18 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getGlobalClassRef: localRefCls = "<<PEGASUS_STD(hex)<<(int)localRefCls<<PEGASUS_STD(dec)<<", name = "<<name<<PEGASUS_STD(endl));
|
190 mark.hamzy 1.16
191 if (localRefCls==NULL)
192 return JNI_FALSE;
193
|
194 schuur 1.1 jclass globalRefCls=(jclass) env->NewGlobalRef(localRefCls);
|
195 mark.hamzy 1.16
|
196 schuur 1.1 env->DeleteLocalRef(localRefCls);
|
197 mark.hamzy 1.16
|
198 schuur 1.1 return globalRefCls;
199 }
200
201 JMPIjvm::JMPIjvm() {
202 initJVM();
203 }
204
205 JMPIjvm::~JMPIjvm() {
|
206 schuur 1.7
|
207 schuur 1.1 }
208
209 int JMPIjvm::cacheIDs(JNIEnv *env) {
|
210 mark.hamzy 1.16 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): enter"<<PEGASUS_STD(endl));
211
212 if (methodInitDone==1)
213 return JNI_TRUE;
214 if (methodInitDone==-1)
215 return JNI_FALSE;
|
216 schuur 1.1
217 methodInitDone=-1;
|
218 mark.hamzy 1.16
|
219 schuur 1.1 for (unsigned i=0; i<(sizeof(classNames)/sizeof(char*)); i++) {
|
220 mark.hamzy 1.16 //////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<classNames[i]<<PEGASUS_STD(endl));
221 if ((classRefs[i]=getGlobalClassRef(env,classNames[i]))==NULL)
222 {
223 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error: Count not find global class ref for "<<classNames[i]<<PEGASUS_STD(endl));
224
225 return JNI_FALSE;
226 }
|
227 schuur 1.1 }
|
228 schuur 1.7
|
229 schuur 1.1 for (unsigned j=0; j<(sizeof(instanceMethodNames)/sizeof(METHOD_STRUCT)); j++) {
|
230 mark.hamzy 1.16 //////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<j<<": "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<PEGASUS_STD(endl));
231 if ((instanceMethodIDs[j]=env->GetMethodID(classRefs[instanceMethodNames[j].clsIndex],
232 instanceMethodNames[j].methodName,instanceMethodNames[j].signature))==NULL)
233 {
234 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error could not get method id for "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<PEGASUS_STD(endl));
|
235 schuur 1.1 return 0;
|
236 mark.hamzy 1.17 }
|
237 mark.hamzy 1.16 }
|
238 schuur 1.1
239 for (unsigned k=0; k<(sizeof(staticMethodNames)/sizeof(METHOD_STRUCT)); k++) {
|
240 mark.hamzy 1.16 //////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<k<<": "<<classNames[staticMethodNames[k].clsIndex]<<": "<<staticMethodNames[k].methodName<<PEGASUS_STD(endl));
241 if ((staticMethodIDs[k]=env->GetStaticMethodID(classRefs[staticMethodNames[k].clsIndex],
242 staticMethodNames[k].methodName,staticMethodNames[k].signature))==NULL)
243 {
244 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error could not get method id for "<<classNames[staticMethodNames[k].clsIndex]<<": "<<staticMethodNames[k].methodName<<PEGASUS_STD(endl));
245 return 0;
246 }
247 }
248
249 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): exit"<<PEGASUS_STD(endl));
250
|
251 schuur 1.1 methodInitDone=1;
|
252 mark.hamzy 1.16
|
253 schuur 1.1 return JNI_TRUE;
254 }
255
256 static void throwCIMException(JNIEnv *env,char *e) {
257 env->ThrowNew(classRefs[13],e);
258 }
259
|
260 schuur 1.3 int JMPIjvm::destroyJVM()
261 {
|
262 mark.hamzy 1.16 DDD(PEGASUS_STD(cerr)<<"--- JPIjvm::destroyJVM()"<<PEGASUS_STD(endl));
263
|
264 schuur 1.3 #ifdef JAVA_DESTROY_VM_WORKS
265 if (jvm!=NULL) {
266 JvmVector *jv;
267 attachThread(&jv);
268 jvm->DestroyJavaVM();
269 jvm=NULL;
270 return 0;
271 }
272 #endif
|
273 mark.hamzy 1.16
|
274 schuur 1.3 return -1;
275 }
276
|
277 schuur 1.1 int JMPIjvm::initJVM()
278 {
279 JavaVMInitArgs vm_args;
280 jint res;
|
281 mark.hamzy 1.16 char *envstring;
|
282 schuur 1.1 JNIEnv *env;
|
283 mark.hamzy 1.16 JavaVMOption *poptions = 0;
284 int maxoption = 0;
285 Array<std::string> JNIoptions;
286 static const char *aENVoptions[][2] = {
287 { "CLASSPATH", "-Djava.class.path=" },
288 { "PEGASUS_JMPI_MAX_HEAP", "-Xmx" },
289 { "PEGASUS_JMPI_INITIAL_HEAP", "-Xms" },
290 { "PEGASUS_JMPI_JAVA_THREAD_STACK_SIZE", "-Xss" }
291 };
292 std::ostringstream oss;
|
293 schuur 1.9
294 #ifdef PEGASUS_DEBUG
|
295 mark.hamzy 1.16 if (getenv("PEGASUS_JMPI_TRACE")) JMPIjvm::trace=1;
296 else JMPIjvm::trace=0;
|
297 schuur 1.9 #else
|
298 mark.hamzy 1.16 JMPIjvm::trace=0;
|
299 schuur 1.9 #endif
|
300 schuur 1.2
|
301 mark.hamzy 1.16 DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM()" << PEGASUS_STD(endl));
302
|
303 schuur 1.1 jv.initRc=0;
304
|
305 mark.hamzy 1.16 envstring=getenv("CLASSPATH");
306 if (envstring==NULL) {
307 jv.initRc=1;
308
309 DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): No CLASSPATH environment variable found" << PEGASUS_STD(endl));
310
311 return -1;
312 }
313
|
314 mark.hamzy 1.20 ///JNIoptions.append ("-Djava.compiler=NONE");
315 ///maxoption++;
316
|
317 mark.hamzy 1.16 for (Uint32 i = 0; i < (int)(sizeof (aENVoptions)/sizeof (aENVoptions[0])); i++)
318 {
319 const char *name = aENVoptions[i][0];
320
321 envstring = getenv (name);
322 if (envstring)
323 {
324 maxoption++;
325
326 oss.str ("");
327 oss << aENVoptions[i][1] << envstring;
328
329 JNIoptions.append (oss.str ());
330
331 DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): " << name << " found! Specifying \"" << oss.str () << "\"" << PEGASUS_STD(endl));
332 }
333 }
334
335 poptions = (JavaVMOption *)calloc (maxoption, sizeof (JavaVMOption));
336 if (!poptions)
337 {
|
338 schuur 1.1 jv.initRc=1;
|
339 mark.hamzy 1.16
340 DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): Could not allocate " << maxoption << " structures of size " << sizeof (JavaVMOption) << PEGASUS_STD(endl));
341
|
342 schuur 1.1 return -1;
343 }
344
|
345 mark.hamzy 1.16 for (Uint32 i=0; i < JNIoptions.size(); i++)
346 {
347 poptions[i].optionString = (char *)JNIoptions[i].c_str ();
348
349 DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): Setting option " << i << " to \"" << poptions[i].optionString << "\"" << PEGASUS_STD(endl));
350 }
351
|
352 schuur 1.1 vm_args.version=0x00010002;
|
353 mark.hamzy 1.16 vm_args.options=poptions;
354 vm_args.nOptions=maxoption;
|
355 schuur 1.1 vm_args.ignoreUnrecognized=JNI_TRUE;
356
357 res=JNI_CreateJavaVM(&jvm,(void**)&env,&vm_args);
|
358 mark.hamzy 1.16
359 if (poptions)
360 {
361 free (poptions);
362 }
363
|
364 schuur 1.1 if (res!=0) {
|
365 mark.hamzy 1.16 DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): Can not create Java VM"<<PEGASUS_STD(endl));
366
|
367 schuur 1.1 exit(1);
368 }
369 jv.jvm=jvm;
370 jv.env=env;
371
372 if (cacheIDs(env)==1) {
373 jv.classRefs=classRefs;
374 jv.instMethodIDs=instanceMethodIDs;
375 }
376
377 if (env->ExceptionOccurred()) {
378 env->ExceptionDescribe();
379 exit(1);
380 }
381
382 return res;
383 }
384
385 JNIEnv* JMPIjvm::attachThread(JvmVector **jvp) {
386 JNIEnv* env;
387 if (jvm==NULL) initJVM();
388 schuur 1.1 jvm->AttachCurrentThread((void**)&env,NULL);
389 *jvp=&jv;
390 return env;
391 }
392
393 void JMPIjvm::detachThread() {
394 jvm->DetachCurrentThread();
395 }
396
397 jobject JMPIjvm::getProvider(JNIEnv *env, String jar, String cln,
398 const char *cn, jclass *cls)
399 {
|
400 mark.hamzy 1.17 jobject gProv=NULL;
401 jclass scls=NULL;
|
402 mark.hamzy 1.16
|
403 mark.hamzy 1.18 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jar = "<<jar<<", cln = "<<cln<<", cn = "<<cn<<", cls = "<<cls<<PEGASUS_STD(endl));
|
404 mark.hamzy 1.17
405 _objectTable.lookup(cln,gProv);
406 _classTable.lookup(cln,scls);
|
407 mark.hamzy 1.18 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(int)gProv<<", scls = "<<(int)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
408 mark.hamzy 1.16
|
409 schuur 1.1 if (gProv) {
410 *cls=scls;
411 return gProv;
412 }
413
414 /*
|
415 mark.hamzy 1.16 DDD(PEGASUS_STD(cout)<<"--- jar: "<<jar<<PEGASUS_STD(endl));
416 DDD(PEGASUS_STD(cout)<<"--- cln: "<<cln<<PEGASUS_STD(endl));
|
417 schuur 1.1
418 jstring jjar=env->NewStringUTF((const char*)jar.getCString());
419 jstring jcln=env->NewStringUTF((const char*)cln.getCString());
420
421 jclass jcls=(jclass)env->CallStaticObjectMethod(classRefs[23],staticMethodIDs[1],
422 jjar,jcln);
423 if (env->ExceptionCheck()) {
424 env->ExceptionDescribe();
|
425 mark.hamzy 1.16 PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<cn<<PEGASUS_STD(endl);
426 ////////return NULL;
|
427 schuur 1.1 }
428 */
429
430 scls=getGlobalClassRef(env,(const char*)cln.getCString());
431 if (env->ExceptionCheck()) {
|
432 mark.hamzy 1.18 DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::getProvider: Provider "<<cn<<" not found"<<PEGASUS_STD(endl));
|
433 mark.hamzy 1.16 DDD(env->ExceptionDescribe());
434
|
435 schuur 1.1 return NULL;
436 }
|
437 mark.hamzy 1.17 *cls=scls;
438
439 if (scls)
440 {
|
441 mark.hamzy 1.18 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: scls = "<<PEGASUS_STD(hex)<<(int)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
442 mark.hamzy 1.17 _classTable.insert(cln,scls);
443 }
|
444 schuur 1.1
445 jmethodID id=env->GetMethodID(*cls,"<init>","()V");
446 jobject lProv=env->NewObject(*cls,id);
447 gProv=(jobject)env->NewGlobalRef(lProv);
448 if (env->ExceptionCheck()) {
|
449 mark.hamzy 1.16 DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<cn<<PEGASUS_STD(endl));
|
450 schuur 1.1 return NULL;
451 }
|
452 mark.hamzy 1.17
453 if (gProv)
454 {
|
455 mark.hamzy 1.18 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(int)gProv<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
456 mark.hamzy 1.17 _objectTable.insert(cln,gProv);
457 }
458
|
459 schuur 1.1 return gProv;
460 }
461
462 jobject JMPIjvm::getProvider(JNIEnv *env, const char *cn, jclass *cls)
463 {
|
464 mark.hamzy 1.17 String cln = cn;
465 jobject gProv=NULL;
466 jclass scls=NULL;
|
467 mark.hamzy 1.16
|
468 mark.hamzy 1.18 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: cn = "<<cn<<", cls = "<<cls<<PEGASUS_STD(endl));
|
469 mark.hamzy 1.17
470 _objectTable.lookup(cln,gProv);
471 _classTable.lookup(cln,scls);
|
472 mark.hamzy 1.18 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(int)gProv<<", scls = "<<(int)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
473 mark.hamzy 1.16
|
474 schuur 1.1 if (gProv) {
475 *cls=scls;
476 return gProv;
477 }
478
479 scls=getGlobalClassRef(env,cn);
480 if (env->ExceptionCheck()) {
|
481 mark.hamzy 1.18 DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::getProvider: Provider "<<cn<<" not found"<<PEGASUS_STD(endl));
|
482 mark.hamzy 1.16 DDD(env->ExceptionDescribe());
483
|
484 schuur 1.1 return NULL;
485 }
|
486 mark.hamzy 1.17 *cls=scls;
487
488 if (scls)
489 {
|
490 mark.hamzy 1.18 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: scls = "<<PEGASUS_STD(hex)<<(int)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
491 mark.hamzy 1.17 _classTable.insert(cln,scls);
492 }
|
493 schuur 1.1
494 jmethodID id=env->GetMethodID(*cls,"<init>","()V");
495 jobject lProv=env->NewObject(*cls,id);
496 gProv=(jobject)env->NewGlobalRef(lProv);
497 if (env->ExceptionCheck()) {
|
498 mark.hamzy 1.16 DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<cn<<PEGASUS_STD(endl));
|
499 schuur 1.1 return NULL;
500 }
|
501 mark.hamzy 1.17
502 if (gProv)
503 {
|
504 mark.hamzy 1.18 DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(int)gProv<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
505 mark.hamzy 1.17 _objectTable.insert(cln,gProv);
506 }
507
|
508 schuur 1.1 return gProv;
509 }
510
511 void JMPIjvm::checkException(JNIEnv *env)
512 {
513 if (env->ExceptionCheck()) {
|
514 schuur 1.7 jstring jMsg=NULL,jId=NULL;
515 int code;
516 const char *cp;
517 String msg=String::EMPTY,id=String::EMPTY;
518
|
519 schuur 1.1 jthrowable err=env->ExceptionOccurred();
|
520 mark.hamzy 1.16 DDD(env->ExceptionDescribe());
|
521 schuur 1.7 if (env->IsInstanceOf(err,JMPIjvm::jv.CIMExceptionClassRef)) {
522 env->ExceptionClear();
523 if (err) {
524 jMsg=(jstring)env->CallObjectMethod(err,JMPIjvm::jv.ThrowableGetMessage);
525 code=(int)env->CallIntMethod(err,JMPIjvm::jv.CIMExceptionGetCode);
526 jId=(jstring)env->CallObjectMethod(err,JMPIjvm::jv.CIMExceptionGetID);
527 if (jId) {
528 cp=env->GetStringUTFChars(jId,NULL);
529 id=String(cp);
530 env->ReleaseStringUTFChars(jId,cp);
531 }
532
533 if (jMsg) {
534 cp=env->GetStringUTFChars(jMsg,NULL);
535 msg=String(cp);
536 env->ReleaseStringUTFChars(jMsg,cp);
537 }
|
538 mark.hamzy 1.16
539 DDD(PEGASUS_STD(cerr)<<"--- throwing Pegasus exception: "<<code<<" "<<id<<" ("<<msg<<")"<<PEGASUS_STD(endl));
540
|
541 schuur 1.7 throw CIMException((CIMStatusCode)code,id+" ("+msg+")");
|
542 mark.hamzy 1.17 }
|
543 schuur 1.7 }
544 else {
545 env->ExceptionDescribe();
546 exit(13);
|
547 schuur 1.1 }
|
548 schuur 1.7 }
|
549 schuur 1.2 }
|
550 schuur 1.1
551 /**************************************************************************
552 * name - NewPlatformString
553 * description - Returns a new Java string object for the specified
554 * platform string.
555 * parameters - env
556 * s Platform encoded string
557 * returns - Java string object pointer or null (0)
558 **************************************************************************/
559 jstring JMPIjvm::NewPlatformString(JNIEnv *env, char *s)
560 {
561 size_t len = strlen(s);
562 jclass cls;
563 jmethodID mid;
564 jbyteArray ary;
565
566 NULL_CHECK0(cls = (*env).FindClass("java/lang/String"));
567 NULL_CHECK0(mid = (*env).GetMethodID(cls, "<init>", "([B)V"));
568 ary = (*env).NewByteArray((jsize)len);
569 if (ary != 0) {
570 jstring str = 0;
571 schuur 1.1 (*env).SetByteArrayRegion(ary, 0, (jsize)len,
572 (jbyte *)s);
573 if (!(*env).ExceptionOccurred()) {
574 str = (jstring)(*env).NewObject(cls, mid, ary);
575 }
576 (*env).DeleteLocalRef(ary);
577 return str;
578 }
579 return 0;
580 }
581
582
583 /**************************************************************************
584 * name - NewPlatformStringArray
585 * description - Returns a new array of Java string objects for the specified
586 * array of platform strings.
587 * parameters - env
588 * strv Platform encoded string array
589 * strc Number of strings in strv
590 * returns - Java string array object pointer
591 **************************************************************************/
592 schuur 1.1 jobjectArray JMPIjvm::NewPlatformStringArray(JNIEnv *env, char **strv, int strc)
593 {
594 jarray cls;
595 jarray ary;
596 int i;
597
598 NULL_CHECK0(cls = (jarray)(*env).FindClass("java/lang/String"));
599 NULL_CHECK0(ary = (*env).NewObjectArray(strc, (jclass)cls, 0));
600 for (i = 0; i < strc; i++) {
601 jstring str = NewPlatformString(env, *strv++);
602 NULL_CHECK0(str);
603 (*env).SetObjectArrayElement((jobjectArray)ary, i, str);
604 (*env).DeleteLocalRef(str);
605 }
606 return (jobjectArray)ary;
607 }
608
609
610
611
612
613 schuur 1.1 extern "C" {
614
615
616 void throwCimException(JNIEnv *jEnv, CIMException & e) {
617 JMPIjvm::cacheIDs(jEnv);
618 jobject ev=jEnv->NewObject(classRefs[13],instanceMethodIDs[18],(jint)e.getCode());
619 jEnv->Throw((jthrowable)ev);
620 }
621
622 void throwFailedException(JNIEnv *jEnv) {
623 JMPIjvm::cacheIDs(jEnv);
624 jobject ev=jEnv->NewObject(classRefs[13],instanceMethodIDs[18],1);
625 jEnv->Throw((jthrowable)ev);
626 }
627
628 void throwNotSupportedException(JNIEnv *jEnv) {
629 JMPIjvm::cacheIDs(jEnv);
630 jobject ev=jEnv->NewObject(classRefs[13],instanceMethodIDs[18],7);
631 jEnv->Throw((jthrowable)ev);
632 }
633
634 schuur 1.1
|
635 schuur 1.7
636
637 // -------------------------------------
638 // ---
639 // - CIMException
640 // ---
641 // -------------------------------------
642
643 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1new
644 (JNIEnv *jEnv, jobject jThs) {
645 jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[41]);
646 }
647
648 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newS
649 (JNIEnv *jEnv, jobject jThs, jstring jM) {
650 jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[42],jM);
651 }
652
653 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSO
654 (JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1) {
655 jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[43],jM,jO1);
656 schuur 1.7 }
657
658 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSOO
659 (JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1, jobject jO2) {
660 jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[44],jM,jO1,jO2);
661 }
662
663 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSOOO
664 (JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1, jobject jO2, jobject jO3) {
665 jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[45],jM,jO1,jO2,jO3);
666 }
667
668
669
|
670 schuur 1.1 // -------------------------------------
671 // ---
672 // - CIMOMHandle
673 // ---
674 // -------------------------------------
675
|
676 schuur 1.7 CIMPropertyList getList(JNIEnv *jEnv, jobjectArray l) {
677 CIMPropertyList pl;
678 if (l) {
679 Array<CIMName> n;
680 for (jsize i=0,s=jEnv->GetArrayLength(l); i<s; i++) {
681 jstring jObj=(jstring)jEnv->GetObjectArrayElement(l,i);
682 const char *pn=jEnv->GetStringUTFChars(jObj,NULL);
683 n.append(pn);
684 jEnv->ReleaseStringUTFChars(jObj,pn);
685 }
686 pl.set(n);
687 }
688 return pl;
689 }
690
|
691 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getClass
|
692 schuur 1.7 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean lo,
|
693 mark.hamzy 1.20 jboolean iq, jboolean ic, jobjectArray jPl)
694 {
695 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
696 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
697 CIMPropertyList pl;
698 OperationContext ctx;
699
700 if (jPl)
701 pl=getList(jEnv,jPl);
702 else
703 pl=CIMPropertyList();
704
|
705 schuur 1.1 try {
|
706 mark.hamzy 1.20 CIMClass cls=ch->getClass(ctx,cop->getNameSpace(),
707 cop->getClassName(),
708 (Boolean)lo,
709 (Boolean)iq,
710 (Boolean)ic,
711 pl);
712
713 return DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass(cls));
|
714 schuur 1.1 }
715 Catch(jEnv);
|
716 mark.hamzy 1.20
|
717 schuur 1.1 return 0;
718 }
719
|
720 schuur 1.7 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createClass
|
721 mark.hamzy 1.22 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCl)
|
722 mark.hamzy 1.20 {
723 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
724 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
|
725 mark.hamzy 1.22 CIMClass *cl = DEBUG_ConvertJavaToC (jint, CIMClass*, jCl);
|
726 mark.hamzy 1.20 OperationContext ctx;
727
|
728 schuur 1.7 try {
729 ch->createClass(ctx,cop->getNameSpace(),*cl);
730 }
731 Catch(jEnv);
732 }
733
734 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setClass
|
735 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCl)
736 {
737 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
738 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
739 CIMClass *cl = DEBUG_ConvertJavaToC (jint, CIMClass*, jCl);
|
740 schuur 1.7 OperationContext ctx;
|
741 mark.hamzy 1.20
|
742 schuur 1.7 try {
743 ch->modifyClass(ctx,cop->getNameSpace(),*cl);
744 }
745 Catch(jEnv);
746 }
747
748 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteClass
|
749 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop)
750 {
751 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
752 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
753 OperationContext ctx;
|
754 schuur 1.7
755 try {
756 ch->deleteClass(ctx,cop->getNameSpace(),cop->getClassName());
757 }
758 Catch(jEnv);
759 }
760
761 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClassNames
|
762 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean deep)
763 {
764 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
765 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
766 CIMNamespaceName ns = cop->getNameSpace();
767 OperationContext ctx;
768
|
769 schuur 1.7 try {
|
770 mark.hamzy 1.20 Array<CIMName> enm = ch->enumerateClassNames(ctx,cop->getNameSpace(),cop->getClassName(),deep);
771 Array<CIMObjectPath> *enmop = new Array<CIMObjectPath>();
772
|
773 schuur 1.7 for (int i=0,m=enm.size(); i<m; i++) {
774 enmop->append(CIMObjectPath(String::EMPTY,ns,enm[i]));
775 }
|
776 mark.hamzy 1.20
777 return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, enmop);
|
778 schuur 1.7 }
779 Catch(jEnv);
|
780 mark.hamzy 1.20
|
781 schuur 1.7 return 0;
782 }
783
784 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClasses
785 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean deep,
|
786 mark.hamzy 1.20 jboolean lo, jboolean iq, jboolean ic)
787 {
788 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
789 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
790 OperationContext ctx;
791
|
792 schuur 1.1 try {
|
793 mark.hamzy 1.20 Array<CIMClass> en=ch->enumerateClasses(ctx,
794 cop->getNameSpace(),
795 cop->getClassName(),
796 deep,
797 (Boolean)lo,
798 iq,
799 ic);
800
801 return DEBUG_ConvertCToJava (Array<CIMClass>*, jint, new Array<CIMClass>(en));
|
802 schuur 1.7 }
803 Catch(jEnv);
|
804 mark.hamzy 1.20
|
805 schuur 1.7 return 0;
806 }
807
808 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getInstance
809 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean lo, jboolean iq, jboolean ic,
|
810 mark.hamzy 1.20 jobjectArray jPl)
811 {
812 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
813 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
814 OperationContext ctx;
815 CIMPropertyList pl;
816
817 if (jPl)
818 pl=getList(jEnv,jPl);
819 else
820 pl=CIMPropertyList();
|
821 schuur 1.7
822 try {
|
823 mark.hamzy 1.20 CIMInstance *inst=new CIMInstance(ch->getInstance(ctx,
824 cop->getNameSpace(),
825 *cop,
826 (Boolean)lo,
827 (Boolean)iq,
828 (Boolean)ic,
829 pl));
830 return DEBUG_ConvertCToJava (CIMInstance*, jint, inst);
|
831 schuur 1.7 }
832 Catch(jEnv);
|
833 mark.hamzy 1.20
|
834 schuur 1.7 return -1;
835 }
836
837 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance
|
838 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop)
839 {
840 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
841 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
842 OperationContext ctx;
|
843 schuur 1.7
844 try {
845 ch->deleteInstance(ctx,cop->getNameSpace(),*cop);
846 }
847 Catch(jEnv);
848 }
849
850 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createInstance
|
851 mark.hamzy 1.22 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCi)
|
852 mark.hamzy 1.20 {
853 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
854 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
|
855 mark.hamzy 1.22 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);
|
856 mark.hamzy 1.20 OperationContext ctx;
857
|
858 schuur 1.7 try {
859 ci->setPath(*cop);
|
860 mark.hamzy 1.20
|
861 schuur 1.7 CIMObjectPath obj=ch->createInstance(ctx,cop->getNameSpace(),*ci);
|
862 mark.hamzy 1.20
863 return DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(obj));
|
864 schuur 1.7 }
865 Catch(jEnv);
|
866 mark.hamzy 1.20
|
867 schuur 1.7 return 0;
868 }
869
870 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1modifyInstance
871 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCi,
|
872 mark.hamzy 1.20 jboolean iq, jobjectArray jPl)
873 {
874 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
875 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
876 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);
877 CIMPropertyList pl = getList(jEnv,jPl);
878 OperationContext ctx;
879
|
880 schuur 1.7 try {
881 ci->setPath(*cop);
882 ch->modifyInstance(ctx,cop->getNameSpace(),*ci,(Boolean)iq,pl);
883 }
884 Catch(jEnv);
885 }
886
887 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstanceNames
|
888 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean deep)
889 {
890 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
891 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
892 OperationContext ctx;
893
|
894 schuur 1.7 try {
895 Array<CIMObjectPath> enm=ch->enumerateInstanceNames(ctx,
|
896 mark.hamzy 1.20 cop->getNameSpace(),
897 cop->getClassName()); //,(Boolean)deep);
898 return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm));
|
899 schuur 1.7 }
900 Catch(jEnv);
|
901 mark.hamzy 1.20
|
902 schuur 1.7 return 0;
903 }
904
905 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstances
906 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean deep,
|
907 mark.hamzy 1.20 jboolean lo, jboolean iq, jboolean ic, jobjectArray jPl)
908 {
909 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
910 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
911 CIMPropertyList pl;
912 OperationContext ctx;
913
914 if (jPl)
915 pl=getList(jEnv,jPl);
916 else
917 pl=CIMPropertyList();
918
|
919 schuur 1.7 try {
|
920 mark.hamzy 1.20 Array<CIMInstance> en=ch->enumerateInstances(ctx,
921 cop->getNameSpace(),
922 cop->getClassName(),
923 deep,
924 lo,
925 iq,
926 ic,
927 pl);
928 return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, new Array<CIMInstance>(en));
|
929 schuur 1.7 }
930 Catch(jEnv);
|
931 mark.hamzy 1.20
|
932 schuur 1.7 return 0;
933 }
934
935 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1execQuery
|
936 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jQuery, jstring jQl)
937 {
938 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
939 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
940 OperationContext ctx;
941 const char *str = jEnv->GetStringUTFChars(jQuery,NULL);
942 String query(str);
|
943 schuur 1.7
944 jEnv->ReleaseStringUTFChars(jQuery,str);
945 str=jEnv->GetStringUTFChars(jQl,NULL);
|
946 mark.hamzy 1.20
|
947 schuur 1.7 String ql(str);
|
948 mark.hamzy 1.20
|
949 schuur 1.7 jEnv->ReleaseStringUTFChars(jQl,str);
950
951 try {
|
952 mark.hamzy 1.20 Array<CIMObject> enm=ch->execQuery(ctx,cop->getNameSpace(),ql,query);
|
953 schuur 1.7 Array<CIMInstance> *enmInst=new Array<CIMInstance>();
|
954 mark.hamzy 1.20
|
955 schuur 1.7 for (int i=0,m=enm.size(); i<m; i++) {
956 enmInst->append(CIMInstance(enm[i]));
|
957 schuur 1.1 }
|
958 mark.hamzy 1.20
959 return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);
|
960 schuur 1.1 }
961 Catch(jEnv);
|
962 mark.hamzy 1.20
|
963 schuur 1.7 return 0;
|
964 schuur 1.1 }
965
|
966 schuur 1.7
|
967 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getProperty
|
968 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jN)
969 {
970 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
971 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
972 OperationContext ctx;
973 const char *str = jEnv->GetStringUTFChars(jN,NULL);
|
974 schuur 1.3
|
975 schuur 1.1 try {
976 CIMName prop(str);
977 CIMValue *cv = new CIMValue(ch->getProperty(ctx, cop->getNameSpace(),*cop,prop));
978 jEnv->ReleaseStringUTFChars(jN,str);
|
979 mark.hamzy 1.20
980 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
981 schuur 1.1 }
982 Catch(jEnv);
|
983 mark.hamzy 1.20
|
984 schuur 1.1 return -1;
985 }
986
|
987 schuur 1.7 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setProperty
|
988 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jPn, jint jV)
989 {
990 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
991 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
992 OperationContext ctx;
993 CIMValue *val = (CIMValue*)jCop;
994 const char *str = jEnv->GetStringUTFChars(jPn,NULL);
995 CIMName pName(str);
996
|
997 schuur 1.7 jEnv->ReleaseStringUTFChars(jPn,str);
998 try {
999 ch->setProperty(ctx,cop->getNameSpace(),*cop,pName,*val);
1000 }
1001 Catch(jEnv);
1002 }
1003
|
1004 mark.hamzy 1.20 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod
1005 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jMn, jobject jIn, jobject jOut)
1006 {
1007 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
1008 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
1009 OperationContext ctx;
1010 const char *str = jEnv->GetStringUTFChars(jMn,NULL);
1011 CIMName method(str);
|
1012 schuur 1.7
1013 jEnv->ReleaseStringUTFChars(jMn,str);
1014
1015 Array<CIMParamValue> in;
1016 Array<CIMParamValue> out;
1017
|
1018 mark.hamzy 1.23 for (int i = 0, m = jEnv->CallIntMethod(jIn,instanceMethodIDs[28]); i < m; i++) {
|
1019 schuur 1.7 JMPIjvm::checkException(jEnv);
|
1020 mark.hamzy 1.20
|
1021 mark.hamzy 1.23 jobject jProp = jEnv->CallObjectMethod(jIn,instanceMethodIDs[16],i);
1022
|
1023 schuur 1.7 JMPIjvm::checkException(jEnv);
|
1024 mark.hamzy 1.20
1025 jint jp = jEnv->CallIntMethod(jProp,instanceMethodIDs[29]);
1026 CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp);
1027
|
1028 schuur 1.7 JMPIjvm::checkException(jEnv);
|
1029 mark.hamzy 1.20
|
1030 schuur 1.7 in.append(CIMParamValue(p->getName().getString(),p->getValue()));
1031 }
1032 try {
|
1033 mark.hamzy 1.23 CIMValue *val = new CIMValue(ch->invokeMethod(ctx,cop->getNameSpace(),*cop,method,in,out));
|
1034 schuur 1.7
1035 for (int i=0,m=out.size(); i<m; i++) {
|
1036 mark.hamzy 1.20 const CIMParamValue &parm = out[i];
1037 const CIMValue v = parm.getValue();
1038 CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize());
1039 jint jp = DEBUG_ConvertCToJava (CIMProperty*, jint, p);
1040 jobject prop = jEnv->NewObject(classRefs[15],instanceMethodIDs[14],jp);
1041
|
1042 schuur 1.7 jEnv->CallVoidMethod(jOut,instanceMethodIDs[15],prop);
1043 }
|
1044 mark.hamzy 1.20 return DEBUG_ConvertCToJava (CIMValue*, jint, val);
1045 }
|
1046 schuur 1.7 Catch(jEnv);
|
1047 mark.hamzy 1.20
|
1048 schuur 1.7 return 0;
1049 }
|
1050 schuur 1.1
|
1051 schuur 1.7 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod24
1052 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jMn,
|
1053 mark.hamzy 1.20 jobjectArray jIn, jobjectArray jOut)
1054 {
1055 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
1056 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
1057 OperationContext ctx;
1058 const char *str = jEnv->GetStringUTFChars(jMn,NULL);
|
1059 schuur 1.7 CIMName method(str);
|
1060 mark.hamzy 1.20
|
1061 schuur 1.7 jEnv->ReleaseStringUTFChars(jMn,str);
1062
1063 Array<CIMParamValue> in;
1064 Array<CIMParamValue> out;
|
1065 schuur 1.3
|
1066 schuur 1.7 for (int i=0,m=jEnv->GetArrayLength(jIn); i<m; i++) {
1067 JMPIjvm::checkException(jEnv);
|
1068 mark.hamzy 1.20
|
1069 schuur 1.7 jobject jArg=jEnv->GetObjectArrayElement(jIn,i);
1070 JMPIjvm::checkException(jEnv);
|
1071 mark.hamzy 1.20
1072 jint jp = jEnv->CallIntMethod(jArg,instanceMethodIDs[39]);
1073 CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jp);
1074
|
1075 schuur 1.7 JMPIjvm::checkException(jEnv);
|
1076 mark.hamzy 1.20
|
1077 schuur 1.7 in.append(*p);
1078 }
|
1079 schuur 1.1 try {
|
1080 schuur 1.7 CIMValue *val=new CIMValue(ch->invokeMethod(ctx,cop->getNameSpace(),*cop,method,in,out));
1081
1082 for (int i=0,m=out.size(),o=jEnv->GetArrayLength(jOut); i<m && i<o; i++) {
|
1083 mark.hamzy 1.24 CIMParamValue *parm = new CIMParamValue (out[i]);
1084 jint jParm = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);
|
1085 mark.hamzy 1.20
|
1086 mark.hamzy 1.17 jEnv->SetObjectArrayElement(jOut,i,
|
1087 mark.hamzy 1.20 jEnv->NewObject(classRefs[29],instanceMethodIDs[40],jParm));
|
1088 schuur 1.7 }
|
1089 mark.hamzy 1.20 return DEBUG_ConvertCToJava (CIMValue*, jint, val);
|
1090 schuur 1.1 }
1091 Catch(jEnv);
|
1092 mark.hamzy 1.20
|
1093 schuur 1.7 return 0;
|
1094 schuur 1.1 }
1095
|
1096 schuur 1.7 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associatorNames
1097 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop,
|
1098 mark.hamzy 1.20 jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole)
1099 {
1100 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
1101 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
1102 OperationContext ctx;
1103 const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL);
|
1104 schuur 1.3
|
1105 schuur 1.7 CIMName assocClass(str);
|
1106 mark.hamzy 1.23
|
1107 schuur 1.7 jEnv->ReleaseStringUTFChars(jAssocClass,str);
|
1108 mark.hamzy 1.23
|
1109 schuur 1.7 str=jEnv->GetStringUTFChars(jResultClass,NULL);
|
1110 mark.hamzy 1.23
|
1111 schuur 1.7 CIMName resultClass(str);
|
1112 mark.hamzy 1.23
|
1113 schuur 1.7 jEnv->ReleaseStringUTFChars(jResultClass,str);
|
1114 mark.hamzy 1.23
|
1115 schuur 1.7 str=jEnv->GetStringUTFChars(jRole,NULL);
|
1116 mark.hamzy 1.23
|
1117 schuur 1.7 String role(str);
|
1118 mark.hamzy 1.23
|
1119 schuur 1.7 jEnv->ReleaseStringUTFChars(jRole,str);
|
1120 mark.hamzy 1.23
|
1121 schuur 1.7 str=jEnv->GetStringUTFChars(jResultRole,NULL);
|
1122 mark.hamzy 1.23
|
1123 schuur 1.7 String resultRole(str);
|
1124 mark.hamzy 1.23
|
1125 schuur 1.7 jEnv->ReleaseStringUTFChars(jResultRole,str);
1126
|
1127 schuur 1.1 try {
|
1128 schuur 1.7 Array<CIMObjectPath> enm=ch->associatorNames(ctx,
|
1129 mark.hamzy 1.23 cop->getNameSpace(),
1130 *cop,
1131 assocClass,
1132 resultClass,
1133 role,
1134 resultRole);
1135
|
1136 mark.hamzy 1.20 return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm));
|
1137 schuur 1.7 }
1138 Catch(jEnv);
|
1139 mark.hamzy 1.20
|
1140 schuur 1.7 return 0;
1141 }
1142
1143 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIM__1associators
1144 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop,
1145 jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole,
|
1146 mark.hamzy 1.20 jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)
1147 {
1148 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
1149 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
1150 OperationContext ctx;
1151 CIMPropertyList pl = getList(jEnv,jPl);
1152 const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL);
|
1153 schuur 1.7
1154 CIMName assocClass(str);
|
1155 mark.hamzy 1.23
|
1156 schuur 1.7 jEnv->ReleaseStringUTFChars(jAssocClass,str);
|
1157 mark.hamzy 1.23
|
1158 schuur 1.7 str=jEnv->GetStringUTFChars(jResultClass,NULL);
|
1159 mark.hamzy 1.23
|
1160 schuur 1.7 CIMName resultClass(str);
|
1161 mark.hamzy 1.23
|
1162 schuur 1.7 jEnv->ReleaseStringUTFChars(jResultClass,str);
|
1163 mark.hamzy 1.23
|
1164 schuur 1.7 str=jEnv->GetStringUTFChars(jRole,NULL);
|
1165 mark.hamzy 1.23
|
1166 schuur 1.7 String role(str);
|
1167 mark.hamzy 1.23
|
1168 schuur 1.7 jEnv->ReleaseStringUTFChars(jRole,str);
|
1169 mark.hamzy 1.23
|
1170 schuur 1.7 str=jEnv->GetStringUTFChars(jResultRole,NULL);
|
1171 mark.hamzy 1.23
|
1172 schuur 1.7 String resultRole(str);
|
1173 mark.hamzy 1.23
|
1174 schuur 1.7 jEnv->ReleaseStringUTFChars(jResultRole,str);
1175
1176 try {
|
1177 mark.hamzy 1.23 Array<CIMObject> enm = ch->associators(ctx,
1178 cop->getNameSpace(),
1179 *cop,
1180 assocClass,
1181 resultClass,
1182 role,
1183 resultRole,
1184 (Boolean)includeQualifiers,
1185 (Boolean)includeClassOrigin,
1186 pl);
1187 Array<CIMInstance> *enmInst = new Array<CIMInstance>();
1188
|
1189 schuur 1.7 for (int i=0,m=enm.size(); i<m; i++) {
1190 enmInst->append(CIMInstance(enm[i]));
|
1191 schuur 1.1 }
|
1192 mark.hamzy 1.23
|
1193 mark.hamzy 1.20 return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);
|
1194 schuur 1.1 }
1195 Catch(jEnv);
|
1196 mark.hamzy 1.20
|
1197 schuur 1.7 return 0;
|
1198 schuur 1.1 }
1199
|
1200 schuur 1.7 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1referenceNames
1201 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop,
|
1202 mark.hamzy 1.20 jstring jAssocClass, jstring jRole)
1203 {
1204 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
1205 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
1206 OperationContext ctx;
1207 const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL);
|
1208 schuur 1.7
1209 CIMName assocClass(str);
|
1210 mark.hamzy 1.23
|
1211 schuur 1.7 jEnv->ReleaseStringUTFChars(jAssocClass,str);
|
1212 mark.hamzy 1.23
|
1213 schuur 1.7 str=jEnv->GetStringUTFChars(jRole,NULL);
|
1214 mark.hamzy 1.23
|
1215 schuur 1.7 String role(str);
|
1216 mark.hamzy 1.23
|
1217 schuur 1.7 jEnv->ReleaseStringUTFChars(jRole,str);
1218
1219 try {
|
1220 mark.hamzy 1.23 Array<CIMObjectPath> enm = ch->referenceNames(ctx,
1221 cop->getNameSpace(),
1222 *cop,
1223 assocClass,
1224 role);
1225
|
1226 mark.hamzy 1.20 return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm));
|
1227 schuur 1.7 }
1228 Catch(jEnv);
|
1229 mark.hamzy 1.20
|
1230 schuur 1.7 return 0;
1231 }
|
1232 schuur 1.1
|
1233 schuur 1.7 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1references
1234 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop,
1235 jstring jAssocClass, jstring jRole,
|
1236 mark.hamzy 1.20 jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)
1237 {
1238 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
1239 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
1240 OperationContext ctx;
1241 CIMPropertyList pl = getList(jEnv,jPl);
1242 const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL);
1243 CIMName assocClass(str);
|
1244 schuur 1.3
|
1245 schuur 1.7 jEnv->ReleaseStringUTFChars(jAssocClass,str);
|
1246 mark.hamzy 1.23
|
1247 schuur 1.7 str=jEnv->GetStringUTFChars(jRole,NULL);
|
1248 mark.hamzy 1.20
|
1249 schuur 1.7 String role(str);
|
1250 mark.hamzy 1.20
|
1251 schuur 1.7 jEnv->ReleaseStringUTFChars(jRole,str);
1252
|
1253 schuur 1.1 try {
|
1254 mark.hamzy 1.23 Array<CIMObject> enm = ch->references(ctx,
1255 cop->getNameSpace(),
1256 *cop,
1257 assocClass,
1258 role,
1259 (Boolean)includeQualifiers,
1260 (Boolean)includeClassOrigin,
1261 pl);
1262 Array<CIMInstance> *enmInst = new Array<CIMInstance>();
1263
|
1264 schuur 1.7 for (int i=0,m=enm.size(); i<m; i++) {
1265 enmInst->append(CIMInstance(enm[i]));
1266 }
|
1267 mark.hamzy 1.23
|
1268 mark.hamzy 1.20 return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);
|
1269 schuur 1.1 }
1270 Catch(jEnv);
|
1271 mark.hamzy 1.20
|
1272 schuur 1.7 return 0;
|
1273 schuur 1.1 }
1274
|
1275 schuur 1.3 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent
|
1276 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCh, jstring jName, jstring jNs, jint jInd)
1277 {
1278 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
1279 CIMInstance *ind = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInd);
1280 const char *str = jEnv->GetStringUTFChars(jName,NULL);
1281 String name(str);
|
1282 schuur 1.1
|
1283 schuur 1.3 jEnv->ReleaseStringUTFChars(jName,str);
1284 str=jEnv->GetStringUTFChars(jNs,NULL);
|
1285 mark.hamzy 1.20
|
1286 schuur 1.3 String ns(str);
|
1287 mark.hamzy 1.20
|
1288 schuur 1.3 jEnv->ReleaseStringUTFChars(jNs,str);
1289
|
1290 schuur 1.8 CIMObjectPath ref(CIMObjectPath(ind->getPath()));
|
1291 mark.hamzy 1.20
|
1292 schuur 1.8 ref.setNameSpace(ns);
1293 ind->setPath(ref);
1294
|
1295 schuur 1.3 JMPIProviderManager::indProvRecord *prec;
1296 OperationContext* context;
1297
1298 if (JMPIProviderManager::provTab.lookup(name,prec)) {
1299 if (prec->enabled) {
1300 context=prec->ctx;
1301 try {
1302 prec->handler->deliver(*context, *ind);
1303 }
1304 Catch(jEnv);
1305 }
1306 }
1307 else {
|
1308 mark.hamzy 1.16 DDD(PEGASUS_STD(cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent() "<<name<<" not found"<<PEGASUS_STD(endl));
|
1309 schuur 1.3 }
1310 }
|
1311 schuur 1.1
|
1312 mark.hamzy 1.21 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1finalize
1313 (JNIEnv *jEnv, jobject jThs, jint jCh)
1314 {
1315 CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
1316
1317 delete ch;
1318
1319 DEBUG_ConvertCleanup (jint, jCh);
1320 }
1321
|
1322 schuur 1.1 // -------------------------------------
1323 // ---
1324 // - CIMClass
1325 // ---
1326 // -------------------------------------
1327
1328 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1newInstance
|
1329 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCls)
1330 {
1331 CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);
1332
|
1333 schuur 1.1 try {
|
1334 mark.hamzy 1.23 CIMInstance *ci = new CIMInstance(cls->getClassName());
|
1335 mark.hamzy 1.20
|
1336 schuur 1.5 for (int i=0,m=cls->getQualifierCount(); i<m; i++) {
1337 try {
1338 ci->addQualifier(cls->getQualifier(i).clone());
|
1339 mark.hamzy 1.17 }
1340 catch (Exception e) {}
|
1341 schuur 1.5 }
|
1342 schuur 1.1 for (int i=0,m=cls->getPropertyCount(); i<m; i++) {
|
1343 mark.hamzy 1.23 CIMProperty cp = cls->getProperty(i);
1344
|
1345 schuur 1.1 ci->addProperty(cp.clone());
|
1346 mark.hamzy 1.23
|
1347 schuur 1.5 for (int j=0, s=cp.getQualifierCount(); j<s; j++) {
1348 try {
1349 ci->getProperty(i).addQualifier(cp.getQualifier(j));
|
1350 mark.hamzy 1.17 }
1351 catch (Exception e) {}
1352 }
|
1353 schuur 1.1 }
|
1354 mark.hamzy 1.23
|
1355 mark.hamzy 1.20 return DEBUG_ConvertCToJava (CIMInstance*, jint, ci);
|
1356 schuur 1.1 }
1357 Catch(jEnv);
|
1358 mark.hamzy 1.20
|
1359 schuur 1.1 return 0;
1360 }
1361
1362 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getName
|
1363 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCls)
1364 {
1365 CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);
|
1366 r.kieninger 1.11
|
1367 schuur 1.1 try {
1368 const String &cn=cls->getClassName().getString();
1369 jstring str=jEnv->NewStringUTF(cn.getCString());
|
1370 mark.hamzy 1.20
|
1371 schuur 1.1 return str;
1372 }
1373 Catch(jEnv);
|
1374 mark.hamzy 1.20
|
1375 schuur 1.1 return 0;
1376 }
1377
1378 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifier
|
1379 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCls, jstring jN)
1380 {
1381 CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);
1382 const char *str = jEnv->GetStringUTFChars(jN,NULL);
1383 jint rv = -1;
1384 Uint32 pos = cls->findQualifier(String(str));
1385
|
1386 schuur 1.1 if (pos!=PEG_NOT_FOUND)
|
1387 mark.hamzy 1.20 rv = DEBUG_ConvertCToJava (CIMQualifier*, jint, new CIMQualifier(cls->getQualifier(pos)));
1388
|
1389 schuur 1.1 jEnv->ReleaseStringUTFChars(jN,str);
|
1390 mark.hamzy 1.20
|
1391 schuur 1.1 return rv;
1392 }
1393
1394 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperty
|
1395 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCls, jstring jN)
1396 {
1397 CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);
1398 const char *str = jEnv->GetStringUTFChars(jN,NULL);
1399 jint rv = -1;
1400 Uint32 pos = cls->findProperty(CIMName(str));
1401
|
1402 schuur 1.1 if (pos!=PEG_NOT_FOUND)
|
1403 mark.hamzy 1.20 rv = DEBUG_ConvertCToJava (CIMProperty*, jint, new CIMProperty(cls->getProperty(pos)));
1404
|
1405 schuur 1.1 jEnv->ReleaseStringUTFChars(jN,str);
|
1406 mark.hamzy 1.20
|
1407 schuur 1.1 return rv;
1408 }
1409
1410 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1hasQualifier
|
1411 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCls, jstring jQ)
1412 {
1413 CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);
1414 const char *str = jEnv->GetStringUTFChars(jQ,NULL);
1415 Uint32 pos = cls->findQualifier(String(str));
1416
|
1417 schuur 1.1 jEnv->ReleaseStringUTFChars(jQ,str);
|
1418 mark.hamzy 1.20
|
1419 schuur 1.1 return (jboolean)(pos!=PEG_NOT_FOUND);
1420 }
1421
1422 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties
|
1423 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec)
1424 {
1425 CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);
|
1426 schuur 1.5
|
1427 schuur 1.1 for (int i=0,s=cls->getPropertyCount(); i<s; i++) {
|
1428 mark.hamzy 1.20 CIMProperty *cp = new CIMProperty(cls->getProperty(i));
1429 jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp);
|
1430 mark.hamzy 1.16
|
1431 mark.hamzy 1.20 jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],jCp);
|
1432 mark.hamzy 1.16
|
1433 schuur 1.1 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop);
1434 }
|
1435 mark.hamzy 1.20
|
1436 schuur 1.1 return jVec;
1437 }
1438
|
1439 schuur 1.5 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1addProperty
|
1440 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCls, jint jP)
1441 {
1442 CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);
1443 CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
1444
|
1445 schuur 1.5 cls->addProperty(*p);
1446 }
1447
1448 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1setProperties
|
1449 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec)
1450 {
1451 CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);
1452
|
1453 schuur 1.5 for (int i=cls->getPropertyCount()-1; i>=0; i--) {
1454 cls->removeProperty(i);
1455 }
1456 for (Uint32 i=0,s=jEnv->CallIntMethod(jVec,instanceMethodIDs[28]); i<s; i++) {
|
1457 mark.hamzy 1.20 JMPIjvm::checkException(jEnv);
1458
|
1459 schuur 1.5 jobject o=jEnv->CallObjectMethod(jVec,instanceMethodIDs[16],(i));
|
1460 mark.hamzy 1.20
1461 jint jp = jEnv->CallIntMethod(o,instanceMethodIDs[29]);
1462 CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp);
1463
1464 JMPIjvm::checkException(jEnv);
1465
|
1466 schuur 1.5 cls->addProperty(*cp);
1467 }
1468 }
1469
1470
1471 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifiers
|
1472 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec)
1473 {
1474 CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);
|
1475 schuur 1.5
1476 for (int i=0,s=cls->getQualifierCount(); i<s; i++) {
|
1477 mark.hamzy 1.20 CIMQualifier *cq = new CIMQualifier(cls->getQualifier(i));
1478 jint jCq = DEBUG_ConvertCToJava (CIMQualifier*, jint, cq);
1479 jobject qual = jEnv->NewObject(classRefs[26],instanceMethodIDs[37],jCq);
1480
|
1481 schuur 1.5 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],qual);
1482 }
|
1483 mark.hamzy 1.20
|
1484 schuur 1.5 return jVec;
1485 }
1486
|
1487 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1new
|
1488 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jstring jN)
1489 {
1490 const char *str = jEnv->GetStringUTFChars(jN,NULL);
1491 CIMClass *cls = new CIMClass(CIMName(str), CIMName());
1492
|
1493 schuur 1.1 jEnv->ReleaseStringUTFChars(jN,str);
|
1494 mark.hamzy 1.20
1495 return DEBUG_ConvertCToJava (CIMClass*, jint, cls);
|
1496 schuur 1.1 }
1497
1498 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getSuperClass
|
1499 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCls)
1500 {
1501 CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);
1502 const String &cn = cls->getSuperClassName().getString();
1503
|
1504 schuur 1.1 jstring str=jEnv->NewStringUTF(cn.getCString());
|
1505 mark.hamzy 1.20
|
1506 schuur 1.1 return str;
1507 }
1508
1509 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getKeys
|
1510 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec)
1511 {
1512 CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);
1513
|
1514 schuur 1.1 if (cls->hasKeys()) {
1515 Array<CIMName> keyNames;
1516 cls->getKeyNames(keyNames);
1517 for(int i=0, s=keyNames.size();i<s;i++){
1518 Uint32 pos=cls->findProperty(keyNames[i]);
1519 if (pos!=PEG_NOT_FOUND){
|
1520 mark.hamzy 1.20 CIMProperty *cp = new CIMProperty(cls->getProperty(pos));
1521 jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp);
1522
1523 jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],jCp);
1524
|
1525 schuur 1.1 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop);
1526 }
1527 }
1528 }
|
1529 mark.hamzy 1.20
|
1530 schuur 1.1 return jVec;
1531 }
1532
1533 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethod
|
1534 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCls, jstring jN)
1535 {
1536 CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);
1537 const char *str = jEnv->GetStringUTFChars(jN,NULL);
1538 jint rv = -1;
1539 Uint32 pos = cls->findMethod(String(str));
1540
|
1541 schuur 1.1 if (pos!=PEG_NOT_FOUND) {
|
1542 mark.hamzy 1.20 rv = DEBUG_ConvertCToJava (CIMMethod*, jint, new CIMMethod(cls->getMethod(pos)));
|
1543 schuur 1.1 }
|
1544 mark.hamzy 1.20
|
1545 schuur 1.1 jEnv->ReleaseStringUTFChars(jN,str);
|
1546 mark.hamzy 1.20
|
1547 schuur 1.1 return rv;
1548 }
1549
1550 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1equals
|
1551 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCls, jint jClsToBeCompared)
1552 {
1553 CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);
1554 CIMClass *clsToBeCompared = DEBUG_ConvertJavaToC (jint, CIMClass*, jClsToBeCompared);
1555
|
1556 schuur 1.1 return cls->identical(*clsToBeCompared);
1557 }
1558
1559 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1finalize
|
1560 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCls)
1561 {
1562 CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);
1563
|
1564 schuur 1.1 delete cls;
|
1565 mark.hamzy 1.20
1566 DEBUG_ConvertCleanup (jint, jCls);
|
1567 schuur 1.1 }
1568
|
1569 schuur 1.7 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1filterProperties
|
1570 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jInst, jobjectArray jPl, jboolean iq, jboolean ic, jboolean lo)
1571 {
1572 CIMClass *cc = DEBUG_ConvertJavaToC (jint, CIMClass*, jInst);
|
1573 mark.hamzy 1.22 CIMClass *cf = 0;
|
1574 mark.hamzy 1.20 CIMName clsn = cc->getClassName();
|
1575 schuur 1.7
1576 if (lo) {
|
1577 mark.hamzy 1.23 cf = new CIMClass(cc->clone());
1578
|
1579 schuur 1.7 CIMName clsn=cc->getClassName();
|
1580 mark.hamzy 1.23
|
1581 schuur 1.7 for (int i=cf->getPropertyCount()-1; i>=0; i--)
1582 if (cf->getProperty(i).getClassOrigin()==clsn) cf->removeProperty(i);
|
1583 mark.hamzy 1.23
|
1584 mark.hamzy 1.20 return DEBUG_ConvertCToJava (CIMClass*, jint, cf);
|
1585 schuur 1.7 }
1586 else if (jPl) {
|
1587 mark.hamzy 1.23 CIMPropertyList pl = getList(jEnv,jPl);
1588 Array<CIMName> n = pl.getPropertyNameArray();
1589
1590 cf = new CIMClass(clsn, cc->getSuperClassName());
1591
1592 for (int i = 0,s = n.size(); i < s; i++) {
|
1593 schuur 1.7 Uint32 pos=cc->findProperty(n[i]);
|
1594 mark.hamzy 1.23
|
1595 schuur 1.7 if (pos!=PEG_NOT_FOUND) {
1596 if (iq) {
|
1597 mark.hamzy 1.23 CIMProperty cp = cc->getProperty(pos).clone();
1598
1599 if (!ic)
1600 cp.setClassOrigin(CIMName());
1601
|
1602 schuur 1.7 cf->addProperty(cp);
1603 }
1604 else {
|
1605 mark.hamzy 1.23 CIMProperty cp = cc->getProperty(pos);
1606 CIMName co;
1607
1608 if (ic)
1609 co = cp.getClassOrigin();
1610
1611 CIMProperty np(cp.getName(),
1612 cp.getValue(),
1613 cp.getArraySize(),
1614 cp.getReferenceClassName(),
1615 co,
1616 cp.getPropagated());
1617
|
1618 schuur 1.7 cf->addProperty(np);
1619 }
1620 }
1621 }
|
1622 mark.hamzy 1.23 if (iq)
1623 for (Uint32 i = 0, s = cc->getQualifierCount(); i < s; i++)
1624 cf->addQualifier(cc->getQualifier(i));
|
1625 schuur 1.7 }
1626 else if (iq) {
|
1627 mark.hamzy 1.23 cf = new CIMClass(cc->clone());
1628
1629 if (ic)
1630 return DEBUG_ConvertCToJava (CIMClass*, jint, cf);
1631
1632 for (int i = cf->getPropertyCount()-1; i >= 0; i--) {
|
1633 schuur 1.7 CIMProperty cp=cf->getProperty(i);
|
1634 mark.hamzy 1.23
|
1635 schuur 1.7 cp.setClassOrigin(CIMName());
1636 cf->removeProperty(i);
1637 cf->addProperty(cp);
1638 }
1639 }
1640 else {
|
1641 mark.hamzy 1.23 cf = new CIMClass(clsn, cc->getSuperClassName());
1642
1643 for (int i = cc->getPropertyCount()-1; i >= 0; i--) {
1644 CIMProperty cp = cc->getProperty(i);
1645 CIMName co;
1646
1647 if (ic)
1648 co = cp.getClassOrigin();
1649
1650 CIMProperty np(cp.getName(),
1651 cp.getValue(),
1652 cp.getArraySize(),
1653 cp.getReferenceClassName(),
1654 co,
1655 cp.getPropagated());
1656
|
1657 schuur 1.7 cf->addProperty(np);
1658 }
1659 }
1660
|
1661 mark.hamzy 1.20 return DEBUG_ConvertCToJava (CIMClass*, jint, cf);
|
1662 schuur 1.7 }
1663
|
1664 schuur 1.1
1665
1666 // -------------------------------------
1667 // ---
1668 // - CIMInstance
1669 // ---
1670
1671 // -------------------------------------
1672 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1new
|
1673 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs)
1674 {
1675 return DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance());
|
1676 schuur 1.1 }
1677
1678 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1newCn
|
1679 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jstring jN)
1680 {
|
1681 schuur 1.1 const char *str=jEnv->GetStringUTFChars(jN,NULL);
|
1682 mark.hamzy 1.20
1683 return DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance(CIMName(str)));
|
1684 schuur 1.1 }
1685
1686 //Added by Andy Viciu
1687 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setName
|
1688 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN)
1689 {
1690 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
1691 const char *str = jEnv->GetStringUTFChars(jN,NULL);
1692
|
1693 schuur 1.1 /* NOT SUPPORTED AND NOT NEEDED*/
1694 }
1695
1696 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperty
|
1697 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN, jint jV)
1698 {
1699 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
1700 CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);
1701 const char *str = jEnv->GetStringUTFChars(jN,NULL);
1702 Uint32 pos = ci->findProperty(CIMName(str));
1703
|
1704 schuur 1.5 try {
|
1705 schuur 1.6 if (pos!=PEG_NOT_FOUND) {
1706 CIMProperty cp=ci->getProperty(pos);
1707 if (cp.getType()==cv->getType())
1708 cp.setValue(*cv);
1709 else {
|
1710 mark.hamzy 1.16 DDD(PEGASUS_STD(cerr)<<"!!! CIMInstance.setProperty - Wrong type of CIMValue (instance name:"<<ci->getClassName().getString()<<", property name: "<<str<<")");
1711 DDD(PEGASUS_STD(cerr)<<"!!! CIMInstance.setProperty : "<<cp.getType()<<" <> "<<cv->getType()<<PEGASUS_STD(endl));
1712
|
1713 schuur 1.6 throw CIMException(CIM_ERR_FAILED, String("Type mismatch"));
1714 }
1715 ci->removeProperty(pos);
1716 ci->addProperty(cp);
1717 }
1718 else {
1719 CIMProperty *cp=new CIMProperty(CIMName(str),*cv);
1720 ci->addProperty(*cp);
|
1721 schuur 1.1 }
1722 }
|
1723 schuur 1.5 Catch(jEnv);
|
1724 schuur 1.1
1725 jEnv->ReleaseStringUTFChars(jN,str);
1726 }
1727
|
1728 schuur 1.5 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperties
|
1729 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jInst, jobject jV)
1730 {
1731 throw CIMException(CIM_ERR_NOT_SUPPORTED, String("Not yet supported"));
|
1732 schuur 1.5 }
1733
|
1734 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperty
|
1735 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN)
1736 {
1737 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
1738 const char *str = jEnv->GetStringUTFChars(jN,NULL);
1739 jint rv = -1;
1740
|
1741 schuur 1.1 try {
|
1742 mark.hamzy 1.23 Uint32 pos = ci->findProperty(CIMName(str));
1743
1744 if (pos != PEG_NOT_FOUND) {
1745 CIMProperty *cp = new CIMProperty(ci->getProperty(pos));
1746
|
1747 mark.hamzy 1.20 rv = DEBUG_ConvertCToJava (CIMProperty*, jint, cp);
|
1748 schuur 1.1 }
1749 }
1750 Catch(jEnv);
|
1751 mark.hamzy 1.20
|
1752 schuur 1.1 jEnv->ReleaseStringUTFChars(jN,str);
|
1753 mark.hamzy 1.20
|
1754 schuur 1.1 return rv;
1755 }
1756
1757 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getKeyValuePairs
|
1758 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jInst, jobject jVec)
1759 {
1760 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
|
1761 schuur 1.5
|
1762 schuur 1.1 for (int i=0,s=ci->getPropertyCount(); i<s; i++) {
1763 if (ci->getProperty(i).findQualifier(String("key"))!=PEG_NOT_FOUND) {
|
1764 mark.hamzy 1.20 CIMProperty *cp = new CIMProperty(ci->getProperty(i));
1765 jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp);
1766
1767 jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],jCp);
1768
|
1769 schuur 1.1 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop);
1770 }
1771 }
1772
1773 return jVec;
1774 }
1775
1776 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMInstance__1getClassName
|
1777 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jInst)
1778 {
1779 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
1780 const String &cn = ci->getClassName().getString();
1781
|
1782 schuur 1.1 jstring str=jEnv->NewStringUTF(cn.getCString());
|
1783 mark.hamzy 1.20
|
1784 schuur 1.1 return str;
1785 }
1786
1787 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getQualifier
|
1788 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN)
1789 {
1790 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
1791 const char *str = jEnv->GetStringUTFChars(jN,NULL);
1792 jint rv = -1;
1793 Uint32 pos = ci->findQualifier(String(str));
1794
|
1795 schuur 1.1 if (pos!=PEG_NOT_FOUND) {
|
1796 mark.hamzy 1.20 rv = DEBUG_ConvertCToJava (CIMQualifier*, jint, new CIMQualifier(ci->getQualifier(pos)));
|
1797 schuur 1.1 }
|
1798 mark.hamzy 1.20
|
1799 schuur 1.1 jEnv->ReleaseStringUTFChars(jN,str);
|
1800 mark.hamzy 1.20
|
1801 schuur 1.1 return rv;
1802 }
1803
1804 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1clone
|
1805 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jInst)
1806 {
1807 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
1808 CIMInstance *cl = new CIMInstance(ci->clone());
1809
1810 return DEBUG_ConvertCToJava (CIMInstance*, jint, cl);
|
1811 schuur 1.1 }
1812
1813 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperties
|
1814 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jInst, jobject jVec)
1815 {
1816 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
|
1817 mark.hamzy 1.16
|
1818 schuur 1.1 for (int i=0,s=ci->getPropertyCount(); i<s; i++) {
|
1819 mark.hamzy 1.20 CIMProperty *cp = new CIMProperty(ci->getProperty(i));
1820 jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp);
|
1821 mark.hamzy 1.16
|
1822 mark.hamzy 1.20 jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],jCp);
|
1823 mark.hamzy 1.16
|
1824 schuur 1.1 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop);
1825 }
|
1826 mark.hamzy 1.16
|
1827 schuur 1.1 return jVec;
1828 }
1829
1830 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1finalize
|
1831 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jInst)
1832 {
1833 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
1834
|
1835 schuur 1.1 delete ci;
|
1836 mark.hamzy 1.20
1837 DEBUG_ConvertCleanup (jint, jInst);
|
1838 schuur 1.1 }
1839
|
1840 schuur 1.7 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1filterProperties
|
1841 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jInst, jobjectArray jPl, jboolean iq, jboolean ic, jboolean lo)
1842 {
1843 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
|
1844 mark.hamzy 1.22 CIMInstance *cf = 0;
|
1845 mark.hamzy 1.20 CIMName clsn = ci->getClassName();
|
1846 schuur 1.7
1847 if (lo) {
1848 cf=new CIMInstance(ci->clone());
1849 CIMName clsn=ci->getClassName();
1850 for (int i=cf->getPropertyCount()-1; i>=0; i--)
1851 if (cf->getProperty(i).getClassOrigin()==clsn) cf->removeProperty(i);
|
1852 mark.hamzy 1.20 return DEBUG_ConvertCToJava (CIMInstance*, jint, cf);
|
1853 schuur 1.7 }
1854 else if (jPl) {
1855 CIMPropertyList pl=getList(jEnv,jPl);
1856 Array<CIMName> n=pl.getPropertyNameArray();
1857 cf=new CIMInstance(clsn);
1858 for (int i=0,s=n.size(); i<s; i++) {
1859 Uint32 pos=ci->findProperty(n[i]);
1860 if (pos!=PEG_NOT_FOUND) {
1861 if (iq) {
1862 CIMProperty cp=ci->getProperty(pos).clone();
1863 if (!ic) cp.setClassOrigin(CIMName());
1864 cf->addProperty(cp);
1865 }
1866 else {
1867 CIMProperty cp=ci->getProperty(pos);
1868 CIMName co;
1869 if (ic) co=cp.getClassOrigin();
1870 CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(),
1871 cp.getReferenceClassName(),co,cp.getPropagated());
1872 cf->addProperty(np);
1873 }
1874 schuur 1.7 }
1875 }
1876 cf->setPath(ci->getPath());
1877 }
1878 else if (iq) {
1879 cf=new CIMInstance(ci->clone());
|
1880 mark.hamzy 1.20 if (ic) return DEBUG_ConvertCToJava (CIMInstance*, jint, cf);
|
1881 schuur 1.7 for (int i=cf->getPropertyCount()-1; i>=0; i--) {
1882 CIMProperty cp=cf->getProperty(i);
1883 cp.setClassOrigin(CIMName());
1884 cf->removeProperty(i);
1885 cf->addProperty(cp);
1886 }
1887 }
1888 else {
1889 cf=new CIMInstance(clsn);
1890 for (int i=ci->getPropertyCount()-1; i>=0; i--) {
1891 CIMProperty cp=ci->getProperty(i);
1892 CIMName co;
1893 if (ic) co=cp.getClassOrigin();
1894 CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(),
1895 cp.getReferenceClassName(),co,cp.getPropagated());
1896 cf->addProperty(np);
1897 }
1898 cf->setPath(ci->getPath());
1899 }
1900
|
1901 mark.hamzy 1.20 return DEBUG_ConvertCToJava (CIMInstance*, jint, cf);
|
1902 schuur 1.7 }
|
1903 schuur 1.1
1904 // -------------------------------------
1905 // ---
1906 // - CIMObjectPath
1907 // ---
1908 // -------------------------------------
1909
|
1910 mark.hamzy 1.20 CIMObjectPath* construct()
1911 {
1912 CIMObjectPath *cop = new CIMObjectPath();
1913 _nameSpace n;
1914
|
1915 schuur 1.1 cop->setNameSpace(n.nameSpace());
1916 cop->setHost(n.hostName());
|
1917 mark.hamzy 1.20
|
1918 schuur 1.1 return cop;
1919 }
1920
1921 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1new
|
1922 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs)
1923 {
1924 return DEBUG_ConvertCToJava (CIMObjectPath*, jint, construct());
|
1925 schuur 1.1 }
1926
1927 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCn
|
1928 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jstring jCn)
1929 {
1930 CIMObjectPath *cop = construct();
1931 const char *str = jEnv->GetStringUTFChars(jCn,NULL);
1932
1933 if (str)
1934 cop->setClassName(str);
|
1935 schuur 1.1 jEnv->ReleaseStringUTFChars(jCn,str);
|
1936 mark.hamzy 1.20
1937 return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);
|
1938 schuur 1.1 }
1939
1940 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCnNs
|
1941 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jstring jCn, jstring jNs)
1942 {
1943 CIMObjectPath *cop = construct();
1944 const char *str1 = NULL;
1945 const char *str2 = NULL;
|
1946 schuur 1.1
1947 try {
|
1948 schuur 1.6 if (jCn) str1=jEnv->GetStringUTFChars(jCn,NULL);
1949 if (jNs) str2=jEnv->GetStringUTFChars(jNs,NULL);
|
1950 schuur 1.1 if (str1) cop->setClassName(str1);
1951 if (str2) cop->setNameSpace(str2);
1952 }
|
1953 schuur 1.5 Catch(jEnv);
|
1954 schuur 1.1
|
1955 schuur 1.6 if (str1) jEnv->ReleaseStringUTFChars(jCn,str1);
1956 if (str2) jEnv->ReleaseStringUTFChars(jNs,str2);
|
1957 mark.hamzy 1.20
1958 return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);
|
1959 schuur 1.1 }
1960
1961 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1_newCi
|
1962 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jInst)
1963 {
1964 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
1965 CIMObjectPath *cop = new CIMObjectPath(ci->getPath());
1966 _nameSpace n;
1967
|
1968 schuur 1.1 if (cop->getNameSpace().isNull()) cop->setNameSpace(n.nameSpace());
1969 if (cop->getHost()==NULL) cop->setHost(n.hostName());
|
1970 mark.hamzy 1.20
1971 return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);
|
1972 schuur 1.1 }
1973
1974 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1finalize
|
1975 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCop)
1976 {
1977 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
1978
|
1979 schuur 1.1 delete cop;
|
1980 mark.hamzy 1.20
1981 DEBUG_ConvertCleanup (jint, jCop);
|
1982 schuur 1.1 }
1983
1984 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getHost
|
1985 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCop)
1986 {
1987 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
1988 const String &hn = cop->getHost();
1989
|
1990 schuur 1.1 jstring str=jEnv->NewStringUTF(hn.getCString());
|
1991 mark.hamzy 1.20
|
1992 schuur 1.1 return str;
1993 }
1994
1995 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setHost
|
1996 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCop, jstring jName)
1997 {
1998 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
1999 const char *str = jEnv->GetStringUTFChars(jName,NULL);
2000
|
2001 schuur 1.1 cop->setHost(String(str));
2002 jEnv->ReleaseStringUTFChars(jName,str);
2003 }
2004
2005 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getObjectName
|
2006 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCop)
2007 {
2008 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
2009 const String &cn = cop->getClassName().getString();
2010
|
2011 schuur 1.1 jstring str=jEnv->NewStringUTF(cn.getCString());
|
2012 mark.hamzy 1.20
|
2013 schuur 1.1 return str;
2014 }
2015
2016 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setObjectName
|
2017 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCop, jstring jName)
2018 {
2019 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
2020 const char *str = jEnv->GetStringUTFChars(jName,NULL);
2021
|
2022 schuur 1.1 cop->setClassName(String(str));
2023 jEnv->ReleaseStringUTFChars(jName,str);
2024 }
2025
2026 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getNameSpace
|
2027 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCop)
2028 {
2029 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
2030 const String &ns = cop->getNameSpace().getString();
2031
|
2032 schuur 1.1 jstring str=jEnv->NewStringUTF(ns.getCString());
|
2033 mark.hamzy 1.20
|
2034 schuur 1.1 return str;
2035 }
2036
2037 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setNameSpace
|
2038 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCop, jstring jName)
2039 {
2040 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
2041 const char *str = jEnv->GetStringUTFChars(jName,NULL);
2042
|
2043 schuur 1.1 cop->setNameSpace(CIMNamespaceName(str));
2044 jEnv->ReleaseStringUTFChars(jName,str);
2045 }
2046
2047 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1addKey
|
2048 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCop, jstring jId, jint jVal)
2049 {
2050 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
2051 const char *str = jEnv->GetStringUTFChars(jId,NULL);
2052 CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jVal);
2053 Array<CIMKeyBinding> keyBindings = cop->getKeyBindings();
2054
|
2055 schuur 1.1 keyBindings.append(CIMKeyBinding(str,*cv));
2056 cop->setKeyBindings(Array<CIMKeyBinding>(keyBindings));
2057 jEnv->ReleaseStringUTFChars(jId,str);
2058 }
2059
2060 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeys
|
2061 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCop, jobject jVec)
2062 {
2063 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
2064 const Array<CIMKeyBinding> &akb = cop->getKeyBindings();
|
2065 schuur 1.1
2066 for (Uint32 i=0,s=akb.size(); i<s; i++) {
2067 const String &n=akb[i].getName().getString();
2068 const String &v=akb[i].getValue();
2069 CIMKeyBinding::Type t=akb[i].getType();
|
2070 mark.hamzy 1.20 CIMValue *cv = 0;
|
2071 schuur 1.1 switch (t) {
2072 case CIMKeyBinding::NUMERIC:
2073 cv=new CIMValue((Sint32)atol(v.getCString()));
2074 break;
2075 case CIMKeyBinding::STRING:
2076 cv=new CIMValue(v);
2077 break;
2078 case CIMKeyBinding::BOOLEAN:
2079 cv=new CIMValue((Boolean)(v.getCString()));
2080 break;
2081 case CIMKeyBinding::REFERENCE:
2082 cv = new CIMValue(CIMObjectPath(akb[i].getValue()));
2083 break;
2084 default:
2085 throwCIMException(jEnv,"+++ unsupported type: ");
2086 }
|
2087 r.kieninger 1.11
|
2088 mark.hamzy 1.20 CIMProperty *cp = 0;
2089 if (t!=CIMKeyBinding::REFERENCE)
|
2090 schuur 1.1 cp=new CIMProperty(n,*cv);
|
2091 mark.hamzy 1.20 else
2092 cp=new CIMProperty(n,*cv, 0, ((CIMObjectPath) akb[i].getValue()).getClassName());
2093
2094 jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp);
2095 jobject prop = jEnv->NewObject(classRefs[15],instanceMethodIDs[14],jCp);
|
2096 schuur 1.1
2097 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop);
2098 }
|
2099 mark.hamzy 1.20
|
2100 schuur 1.1 return jVec;
2101 }
2102
2103 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeyValue
|
2104 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCop, jstring jStr)
2105 {
2106 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
2107 const Array<CIMKeyBinding> &akb = cop->getKeyBindings();
2108 const char *strKeyName = jEnv->GetStringUTFChars(jStr,NULL);
2109 jstring retStr = NULL;
2110
|
2111 schuur 1.1 for (Uint32 i=0,s=akb.size(); i<s; i++) {
2112 const String &n=akb[i].getName().getString();
2113 if (n==String(strKeyName)) {
2114 retStr=jEnv->NewStringUTF(akb[i].getValue().getCString());
2115 break;
2116 }
2117 }
|
2118 mark.hamzy 1.20
|
2119 schuur 1.1 jEnv->ReleaseStringUTFChars(jStr,strKeyName);
|
2120 mark.hamzy 1.20
|
2121 schuur 1.1 return retStr;
2122 }
2123
2124 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1set
|
2125 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jstring jStr)
2126 {
2127 const char *strCop = jEnv->GetStringUTFChars(jStr,NULL);
2128 CIMObjectPath *cop = new CIMObjectPath();
2129
|
2130 schuur 1.1 cop->set(String(strCop));
2131 jEnv->ReleaseStringUTFChars(jStr,strCop);
|
2132 mark.hamzy 1.20
2133 return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);
|
2134 schuur 1.1 }
2135
2136 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setKeys
|
2137 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCop, jobject jVec)
2138 {
2139 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
2140 Array<CIMKeyBinding> akb;
2141
|
2142 schuur 1.6 for (Uint32 i=0,s=jEnv->CallIntMethod(jVec,instanceMethodIDs[28]); i<s; i++) {
2143 jobject o=jEnv->CallObjectMethod(jVec,instanceMethodIDs[16],(i));
|
2144 mark.hamzy 1.20
2145 jint jCp = jEnv->CallIntMethod(o,instanceMethodIDs[29]);
2146 CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jCp);
2147
|
2148 schuur 1.1 akb.append(CIMKeyBinding(cp->getName(),cp->getValue()));
2149 }
2150 cop->setKeyBindings(akb);
2151 }
2152
2153 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1clone
|
2154 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCop)
2155 {
2156 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
2157 CIMObjectPath *copl = new CIMObjectPath(cop->getHost(), cop->getNameSpace(), cop->getClassName(), cop->getKeyBindings());
2158
2159 return DEBUG_ConvertCToJava (CIMObjectPath*, jint, copl);
|
2160 schuur 1.1 }
2161
2162 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1toString
|
2163 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCop)
2164 {
2165 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
2166 const String &ns = cop->toString();
2167
|
2168 schuur 1.1 jstring str=jEnv->NewStringUTF(ns.getCString());
|
2169 mark.hamzy 1.20
|
2170 schuur 1.1 return str;
2171 }
2172
2173 // -------------------------------------
2174 // ---
2175 // - CIMDataType
2176 // ---
2177 // -------------------------------------
2178
2179 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1new
|
2180 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint type)
2181 {
2182 return DEBUG_ConvertCToJava (_dataType*, jint, new _dataType(type));
|
2183 schuur 1.1 }
2184
2185 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newAr
|
2186 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint type, jint size)
2187 {
2188 return DEBUG_ConvertCToJava (_dataType*, jint, new _dataType(type,size));
|
2189 schuur 1.1 }
2190
2191 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newRef
|
2192 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint type, jstring jRef)
2193 {
2194 const char *ref = jEnv->GetStringUTFChars(jRef,NULL);
2195 jint cInst = DEBUG_ConvertCToJava (_dataType*, jint, new _dataType(type,String(ref)));
2196
|
2197 schuur 1.1 jEnv->ReleaseStringUTFChars(jRef,ref);
|
2198 mark.hamzy 1.20
|
2199 schuur 1.1 return cInst;
2200 }
2201
2202 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isArray
|
2203 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jDt)
2204 {
2205 _dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);
2206
|
2207 schuur 1.1 return dt->_array==true;
2208 }
2209
2210 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isreference
|
2211 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jDt)
2212 {
2213 _dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);
2214
|
2215 schuur 1.1 return dt->_reference==true;
2216 }
2217
2218 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isReference
|
2219 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jDt)
2220 {
2221 _dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);
2222
|
2223 schuur 1.1 return dt->_reference==true;
2224 }
2225
2226 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getType
|
2227 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jDt)
2228 {
2229 _dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);
2230
|
2231 schuur 1.1 return dt->_type;
2232 }
2233
2234 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getSize
|
2235 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jDt)
2236 {
2237 _dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);
2238
|
2239 schuur 1.1 return dt->_size;
2240 }
2241
2242 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1getRefClassName
|
2243 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jDt)
2244 {
2245 _dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);
2246 jstring str = jEnv->NewStringUTF(dt->_refClass.getCString());
2247
|
2248 schuur 1.1 return str;
2249 }
2250
2251 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1toString
|
2252 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jDt)
2253 {
2254 _dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);
2255 jstring str = NULL;
2256
|
2257 schuur 1.1 if (dt->_type & 0x10) {
2258 char tmp[32];
2259 strcpy(tmp,jTypeToChars[dt->_type-0x10]);
2260 strcat(tmp,"[]");
2261 str=jEnv->NewStringUTF(tmp);
|
2262 schuur 1.5 }
|
2263 schuur 1.1 else if (dt->_type & 0x20) {
2264 String tmp=dt->_refClass+" REF";
2265 str=jEnv->NewStringUTF(tmp.getCString());
|
2266 schuur 1.6 }
|
2267 schuur 1.1 else {
2268 str=jEnv->NewStringUTF(jTypeToChars[dt->_type]);
2269 }
|
2270 mark.hamzy 1.20
|
2271 schuur 1.1 return str;
2272 }
2273
|
2274 mark.hamzy 1.24 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDataType__1finalize
2275 (JNIEnv *jEnv, jobject jThs, jint jDt)
2276 {
2277 _dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);
2278
2279 delete dt;
2280
2281 DEBUG_ConvertCleanup (jint, jDt);
2282 }
2283
2284 CIMType toPtype (int jType)
2285 {
2286 if (jType > 13)
2287 return (CIMType)14;
2288 return
2289 (CIMType)(jTypeToPType[jType]);
|
2290 schuur 1.5 }
|
2291 schuur 1.1
2292
2293 // -------------------------------------
2294 // ---
|
2295 schuur 1.6 // - CIMArgument
2296 // ---
2297 // -------------------------------------
2298
2299 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1getValue
|
2300 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP)
2301 {
2302 CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP);
2303 CIMValue *cv = new CIMValue(cp->getValue());
2304
2305 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
2306 schuur 1.6 }
2307
2308 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1new
|
2309 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs)
2310 {
2311 CIMParamValue *p = new CIMParamValue(String::EMPTY,CIMValue());
2312
2313 return DEBUG_ConvertCToJava (CIMParamValue*, jint, p);
|
2314 schuur 1.6 }
2315
2316 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1newS
|
2317 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jstring jN)
2318 {
2319 const char *str = jEnv->GetStringUTFChars(jN,NULL);
2320 CIMParamValue *p = new CIMParamValue(str,CIMValue());
2321
|
2322 schuur 1.6 jEnv->ReleaseStringUTFChars(jN,str);
|
2323 mark.hamzy 1.20
2324 return DEBUG_ConvertCToJava (CIMParamValue*, jint, p);
|
2325 schuur 1.6 }
2326
2327 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1newSV
|
2328 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jstring jN, jint jV)
2329 {
2330 const char *str = jEnv->GetStringUTFChars(jN,NULL);
2331 CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);
2332 CIMParamValue *p = new CIMParamValue(str,cv);
2333
|
2334 schuur 1.6 jEnv->ReleaseStringUTFChars(jN,str);
|
2335 mark.hamzy 1.20
2336 return DEBUG_ConvertCToJava (CIMParamValue*, jint, p);
|
2337 schuur 1.6 }
2338
2339 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setValue
|
2340 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP,jint jV)
2341 {
2342 CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP);
2343 CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);
2344
|
2345 schuur 1.6 cp->setValue(*cv);
2346 }
2347
2348 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMArgument__1getName
|
2349 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP)
2350 {
2351 CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP);
2352 const String &n = cp->getParameterName();
2353 jstring str = jEnv->NewStringUTF(n.getCString());
2354
|
2355 schuur 1.6 return str;
2356 }
2357
2358 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setName
|
2359 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP, jstring jN)
2360 {
2361 CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP);
2362 const char *str = jEnv->GetStringUTFChars(jN,NULL);
2363 String n(str);
2364
|
2365 schuur 1.6 cp->setParameterName(n);
2366 jEnv->ReleaseStringUTFChars(jN,str);
2367 }
2368
2369 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1getType
|
2370 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP)
2371 {
2372 CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP);
2373 const CIMValue cv = cp->getValue();
2374 String ref;
2375 _dataType *type = new _dataType(pTypeToJType[cv.getType()],
2376 cv.getArraySize(),
2377 false,
2378 false,
2379 cv.isArray(),
2380 ref,
2381 true);
2382
2383 return DEBUG_ConvertCToJava (_dataType*, jint, type);
|
2384 schuur 1.6 }
2385
2386 // -------------------------------------
2387 // ---
|
2388 schuur 1.1 // - CIMProperty
2389 // ---
2390 // -------------------------------------
2391
2392 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getValue
|
2393 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP)
2394 {
2395 CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
2396 CIMValue *cv = new CIMValue(cp->getValue());
2397
2398 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
2399 schuur 1.1 }
2400
|
2401 schuur 1.5 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1new
|
2402 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jstring jN, jint jV)
2403 {
2404 CIMProperty *p = new CIMProperty(CIMName(),CIMValue());
2405
2406 return DEBUG_ConvertCToJava (CIMProperty*, jint, p);
|
2407 schuur 1.5 }
2408
|
2409 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1property
|
2410 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jstring jN, jint jV)
2411 {
|
2412 schuur 1.1 try {
|
2413 mark.hamzy 1.20 CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);
2414 const char *str = jEnv->GetStringUTFChars(jN,NULL);
2415 CIMProperty *cp = 0;
|
2416 schuur 1.1
2417 if (cv->getType()!=CIMTYPE_REFERENCE)
2418 cp=new CIMProperty(String(str),*cv);
2419 else {
2420 if (!cv->isArray()) {
2421 CIMObjectPath cop;
2422 cv->get(cop);
2423 cp=new CIMProperty(String(str),*cv,0, cop.getClassName());
2424 }
2425 else {
2426 throwCIMException(jEnv,"+++ unsupported type in CIMProperty.property");
2427 }
2428 }
2429
2430 jEnv->ReleaseStringUTFChars(jN,str);
|
2431 mark.hamzy 1.20
2432 return DEBUG_ConvertCToJava (CIMProperty*, jint, cp);
|
2433 schuur 1.1 }
2434 Catch(jEnv);
|
2435 mark.hamzy 1.20
|
2436 schuur 1.1 return -1;
2437 }
2438
2439 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setValue
|
2440 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP,jint jV)
2441 {
2442 CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
2443 CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);
2444
|
2445 schuur 1.1 cp->setValue(*cv);
2446 }
2447
2448 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isArray
|
2449 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP)
2450 {
2451 CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
2452
|
2453 schuur 1.1 return (jboolean)cp->isArray();
2454 }
2455
2456 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addValue
|
2457 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP, jint jV)
2458 {
2459 CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
2460 CIMValue *cvin = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);
2461 CIMValue cv = cp->getValue();
2462
|
2463 schuur 1.1 if (cvin->isNull())
2464 throwCIMException(jEnv,"+++ null cvin value ");
2465 if (!cv.isArray())
2466 throwCIMException(jEnv,"+++ not an array ");
2467 if (cvin->getType()!=cv.getType())
2468 throwCIMException(jEnv,"+++ type mismatch ");
|
2469 mark.hamzy 1.20
|
2470 schuur 1.1 CIMType type=cv.getType();
|
2471 mark.hamzy 1.20
|
2472 schuur 1.1 switch (type) {
2473 case CIMTYPE_BOOLEAN: {
2474 Boolean bo;
2475 cvin->get(bo);
2476 Array<Boolean> boarr;
2477 cv.get(boarr);
2478 boarr.append(bo);
2479 }
2480 break;
2481 case CIMTYPE_UINT8: {
2482 Uint8 u8;
2483 cvin->get(u8);
2484 Array<Uint8> u8arr;
2485 cv.get(u8arr);
2486 u8arr.append(u8);
2487 }
2488 break;
2489 case CIMTYPE_SINT8: {
2490 Sint8 s8;
2491 cvin->get(s8);
2492 Array<Sint8> s8arr;
2493 schuur 1.1 cv.get(s8arr);
2494 s8arr.append(s8);
2495 }
2496 break;
2497 case CIMTYPE_UINT16: {
2498 Uint16 u16;
2499 cvin->get(u16);
2500 Array<Uint16> u16arr;
2501 cv.get(u16arr);
2502 u16arr.append(u16);
2503 }
2504 break;
2505 case CIMTYPE_SINT16: {
2506 Sint16 s16;
2507 cvin->get(s16);
2508 Array<Sint16> s16arr;
2509 cv.get(s16arr);
2510 s16arr.append(s16);
2511 }
2512 break;
2513 case CIMTYPE_UINT32: {
2514 schuur 1.1 Uint32 u32;
2515 cvin->get(u32);
2516 Array<Uint32> u32arr;
2517 cv.get(u32arr);
2518 u32arr.append(u32);
2519 }
2520 break;
2521 case CIMTYPE_SINT32: {
2522 Sint32 s32;
2523 cvin->get(s32);
2524 Array<Sint32> s32arr;
2525 cv.get(s32arr);
2526 s32arr.append(s32);
2527 }
2528 break;
2529 case CIMTYPE_UINT64: {
2530 Uint64 u64;
2531 cvin->get(u64);
2532 Array<Uint64> u64arr;
2533 cv.get(u64arr);
2534 u64arr.append(u64);
2535 schuur 1.1 }
2536 break;
2537 case CIMTYPE_SINT64: {
2538 Sint64 s64;
2539 cvin->get(s64);
2540 Array<Sint64> s64arr;
2541 cv.get(s64arr);
2542 s64arr.append(s64);
2543 }
2544 break;
2545 case CIMTYPE_REAL32: {
2546 Real32 f;
2547 cvin->get(f);
2548 Array<Real32> farr;
2549 cv.get(farr);
2550 farr.append(f);
2551 }
2552 break;
2553 case CIMTYPE_REAL64: {
2554 Real64 d;
2555 cvin->get(d);
2556 schuur 1.1 Array<Real64> darr;
2557 cv.get(darr);
2558 darr.append(d);
2559 }
2560 break;
2561 case CIMTYPE_STRING: {
2562 String str;
2563 cvin->get(str);
2564 Array<String> strarr;
2565 cv.get(strarr);
2566 strarr.append(str);
2567 }
2568 break;
2569 case CIMTYPE_REFERENCE: {
2570 CIMObjectPath ref;
2571 cvin->get(ref);
2572 Array<CIMObjectPath> refarr;
2573 cv.get(refarr);
2574 refarr.append(ref);
2575 }
2576 break;
|
2577 dave.sudlik 1.13 case CIMTYPE_OBJECT: {
2578 CIMObject obj;
2579 cvin->get(obj);
2580 Array<CIMObject> objarr;
2581 cv.get(objarr);
2582 objarr.append(obj);
2583 }
2584 break;
|
2585 schuur 1.1 default:
2586 throwCIMException(jEnv,"+++ unsupported type ");
2587 }
2588 }
2589
|
2590 schuur 1.5 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addQualifier
|
2591 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP, jint jQ)
2592 {
2593 CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
2594 CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);
2595
|
2596 schuur 1.5 cp->addQualifier(*cq);
2597 }
2598
|
2599 schuur 1.1 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getName
|
2600 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP)
2601 {
2602 CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
2603 const String &n = cp->getName().getString();
2604 jstring str = jEnv->NewStringUTF(n.getCString());
2605
|
2606 schuur 1.1 return str;
2607 }
2608
|
2609 schuur 1.5 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setName
|
2610 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP, jstring jN)
2611 {
2612 CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
2613 const char *str = jEnv->GetStringUTFChars(jN,NULL);
2614
|
2615 schuur 1.5 cp->setName(CIMName(str));
2616 jEnv->ReleaseStringUTFChars(jN,str);
2617 }
2618
|
2619 schuur 1.1 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isReference
|
2620 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP)
2621 {
2622 CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
2623
|
2624 schuur 1.1 return (jboolean)(cp->getType()==CIMTYPE_REFERENCE);
2625 }
2626
2627 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getRefClassName
|
2628 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP)
2629 {
2630 CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
2631 const String &n = cp->getReferenceClassName().getString();
2632
|
2633 schuur 1.1 jstring str=jEnv->NewStringUTF(n.getCString());
|
2634 mark.hamzy 1.20
|
2635 schuur 1.1 return str;
2636 }
2637
2638 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getType
|
2639 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP)
2640 {
2641 CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
2642 String ref = cp->getReferenceClassName().getString();
2643 _dataType *type = new _dataType(pTypeToJType[cp->getType()],
2644 cp->getArraySize(),
2645 ref.size() ? true : false,
2646 false,
2647 cp->isArray(),
2648 ref,
2649 true);
2650
2651 return DEBUG_ConvertCToJava (_dataType*, jint, type);
|
2652 schuur 1.1 }
2653
|
2654 schuur 1.5 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1setType
|
2655 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP, jint jDt)
2656 {
2657 CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
2658 _dataType *dt = (_dataType*)jDt;
2659 CIMValue val;
2660
|
2661 schuur 1.5 val.setNullValue(toPtype(dt->_type),dt->_array);
|
2662 mark.hamzy 1.20
2663 CIMProperty *np = new CIMProperty(cp->getName(),val);
2664
|
2665 schuur 1.5 delete cp;
|
2666 mark.hamzy 1.20
2667 return DEBUG_ConvertCToJava (CIMProperty*, jint, np);
|
2668 schuur 1.5 }
2669
|
2670 schuur 1.1 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMProperty__1getIdentifier
|
2671 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP)
2672 {
2673 CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
2674 const String &n = cp->getName().getString();
2675 jstring str = jEnv->NewStringUTF(n.getCString());
2676
|
2677 schuur 1.1 return str;
2678 }
2679
2680 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1finalize
|
2681 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP)
2682 {
2683 CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
2684
|
2685 schuur 1.1 delete cp;
|
2686 mark.hamzy 1.20
2687 DEBUG_ConvertCleanup (jint, jP);
|
2688 schuur 1.1 }
|
2689 schuur 1.5
2690 // -------------------------------------
2691 // ---
2692 // - CIMQualifierType
2693 // ---
2694 // -------------------------------------
2695
2696 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1new
|
2697 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs)
2698 {
|
2699 schuur 1.5 CIMQualifierDecl *qual = new CIMQualifierDecl();
|
2700 mark.hamzy 1.20
2701 return DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, qual);
|
2702 schuur 1.5 }
2703
2704 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1finalize
|
2705 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jQ)
2706 {
2707 CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ);
2708
|
2709 schuur 1.5 delete qt;
|
2710 mark.hamzy 1.20
2711 DEBUG_ConvertCleanup (jint, jQ);
|
2712 schuur 1.5 }
2713
2714 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1getName
|
2715 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jQ)
2716 {
2717 CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ);
2718 const String &n = qt->getName().getString();
2719 jstring str = jEnv->NewStringUTF(n.getCString());
2720
|
2721 schuur 1.5 return str;
2722 }
2723
|
2724 schuur 1.6 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setName
|
2725 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jQ, jstring jN)
2726 {
|
2727 mark.hamzy 1.24 CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ);
2728 const char *str = jEnv->GetStringUTFChars(jN,NULL);
2729 jint jret = 0;
|
2730 mark.hamzy 1.20
|
2731 schuur 1.6 if (qt->isUninitialized())
|
2732 mark.hamzy 1.24 {
2733 CIMQualifierDecl *nqt = new CIMQualifierDecl(CIMName(str),CIMValue(),CIMScope());
2734
2735 jret = DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, nqt);
2736 }
|
2737 mark.hamzy 1.20 else
|
2738 mark.hamzy 1.24 {
|
2739 mark.hamzy 1.20 qt->setName(CIMName(str));
|
2740 mark.hamzy 1.24
2741 CIMQualifierDecl *nqt = new CIMQualifierDecl(*qt);
2742
2743 jret = DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, nqt);
2744 }
2745
|
2746 schuur 1.5 jEnv->ReleaseStringUTFChars(jN,str);
|
2747 mark.hamzy 1.20
|
2748 mark.hamzy 1.24 return jret;
|
2749 schuur 1.5 }
2750
2751 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setValue
|
2752 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jQ,jint jV)
2753 {
2754 CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ);
2755 CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);
2756
|
2757 schuur 1.5 qt->setValue(*cv);
2758 }
2759
|
2760 schuur 1.1 // -------------------------------------
2761 // ---
2762 // - CIMQualifier
2763 // ---
2764 // -------------------------------------
2765
|
2766 schuur 1.5 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifier__1new
|
2767 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jstring jN)
2768 {
2769 const char *str = jEnv->GetStringUTFChars(jN,NULL);
|
2770 schuur 1.5 CIMQualifier *qual = new CIMQualifier(CIMName(str),CIMValue());
|
2771 mark.hamzy 1.20
|
2772 schuur 1.5 jEnv->ReleaseStringUTFChars(jN,str);
|
2773 mark.hamzy 1.20
2774 return DEBUG_ConvertCToJava (CIMQualifier*, jint, qual);
|
2775 schuur 1.5 }
2776
|
2777 schuur 1.1 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1finalize
|
2778 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jQ)
2779 {
2780 CIMQualifier *cq=DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);
2781
|
2782 schuur 1.1 delete cq;
|
2783 mark.hamzy 1.20
2784 DEBUG_ConvertCleanup (jint, jQ);
|
2785 schuur 1.1 }
2786
|
2787 schuur 1.5 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getName
|
2788 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jQ)
2789 {
2790 CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);
2791 const String &n = cq->getName().getString();
2792 jstring str = jEnv->NewStringUTF(n.getCString());
2793
|
2794 schuur 1.5 return str;
2795 }
2796
2797 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getValue
|
2798 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jQ)
2799 {
2800 CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);
2801 CIMValue *cv = new CIMValue(cq->getValue());
2802
2803 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
2804 schuur 1.5 }
2805
2806 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1setValue
|
2807 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jQ,jint jV)
2808 {
2809 CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);
2810 CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);
2811
|
2812 schuur 1.5 cq->setValue(*cv);
2813 }
2814
|
2815 schuur 1.1 // -------------------------------------
2816 // ---
2817 // - CIMDateTime
2818 // ---
2819 // -------------------------------------
2820
2821 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetime
|
2822 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jstring jN)
2823 {
2824 const char *str = jEnv->GetStringUTFChars(jN,NULL);
2825 CIMDateTime *dt = 0;
2826
|
2827 schuur 1.1 if (strlen(str)==0)
2828 dt=new CIMDateTime();
2829 else
2830 dt=new CIMDateTime(String(str));
2831 jEnv->ReleaseStringUTFChars(jN,str);
|
2832 mark.hamzy 1.20
2833 return DEBUG_ConvertCToJava (CIMDateTime*, jint, dt);
|
2834 schuur 1.1 }
2835
2836 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetimeempty
|
2837 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs)
2838 {
2839 CIMDateTime *dt = new CIMDateTime(CIMDateTime::getCurrentDateTime ());
2840
2841 return DEBUG_ConvertCToJava (CIMDateTime*, jint, dt);
|
2842 schuur 1.1 }
2843
2844 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1after
|
2845 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jC, jint jD)
2846 {
2847 CIMDateTime *ct = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jC);
2848 CIMDateTime *dt = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jD);
2849
|
2850 schuur 1.1 return (jboolean)(ct->getDifference(*ct, *dt)>0);
2851 }
2852
2853 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDateTime__1finalize
|
2854 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jDT)
2855 {
2856 CIMDateTime *cdt = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jDT);
2857
|
2858 schuur 1.1 delete cdt;
|
2859 mark.hamzy 1.20
2860 DEBUG_ConvertCleanup (jint, jDT);
|
2861 schuur 1.1 }
2862
2863 // -------------------------------------
2864 // ---
2865 // - CIMMethod
2866 // ---
2867 // -------------------------------------
2868
2869 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1getType
|
2870 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jM)
2871 {
2872 CIMMethod *cm = DEBUG_ConvertJavaToC (jint, CIMMethod*, jM);
2873
|
2874 mark.hamzy 1.24 return DEBUG_ConvertCToJava (CIMType, jint, new CIMType (cm->getType()));
|
2875 schuur 1.1 }
2876
2877 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize
|
2878 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jM)
2879 {
2880 CIMMethod *cm = DEBUG_ConvertJavaToC (jint, CIMMethod*, jM);
2881
|
2882 schuur 1.1 delete cm;
|
2883 mark.hamzy 1.20
2884 DEBUG_ConvertCleanup (jint, jM);
|
2885 schuur 1.1 }
2886
2887 // -------------------------------------
2888 // ---
2889 // - CIMValue
2890 // ---
2891 // -------------------------------------
2892
2893
2894 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byte
|
2895 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jbyte jb, jboolean notSigned)
2896 {
2897 CIMValue *cv = NULL;
2898
2899 if (notSigned)
2900 cv=new CIMValue((Uint8)jb);
2901 else
2902 cv=new CIMValue((Sint8)jb);
2903
2904 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
2905 schuur 1.1 }
2906
2907 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1short
|
2908 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jshort js, jboolean notSigned)
2909 {
2910 CIMValue *cv = NULL;
2911
2912 if (notSigned)
2913 cv=new CIMValue((Uint16)js);
2914 else
2915 cv=new CIMValue((Sint16)js);
2916
2917 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
2918 schuur 1.1 }
2919
2920 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue_makeInt
|
2921 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jlong ji, jboolean notSigned)
2922 {
2923 CIMValue *cv = NULL;
2924
2925 if (notSigned)
2926 cv = new CIMValue((Uint32)ji);
2927 else
2928 cv = new CIMValue((Sint32)ji);
2929
2930 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
2931 schuur 1.1 }
2932
2933 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1long
|
2934 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jlong jl, jboolean notSigned)
2935 {
2936 CIMValue *cv = NULL;
2937
2938 if (notSigned)
2939 cv=new CIMValue((Uint64)jl);
2940 else
2941 cv=new CIMValue((Sint64)jl);
2942
2943 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
2944 schuur 1.1 }
2945
2946 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1float
|
2947 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jfloat jF)
2948 {
2949 CIMValue *cv = new CIMValue(jF);
2950
2951 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
2952 schuur 1.1 }
2953
2954 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1double
|
2955 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jdouble jD)
2956 {
2957 CIMValue *cv = new CIMValue(jD);
2958
2959 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
2960 schuur 1.1 }
2961
2962 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1string
|
2963 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jstring jS)
2964 {
2965 const char *str = jEnv->GetStringUTFChars(jS,NULL);
2966 CIMValue *cv = new CIMValue(String(str));
2967
|
2968 schuur 1.1 jEnv->ReleaseStringUTFChars(jS,str);
|
2969 mark.hamzy 1.20
2970 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
2971 schuur 1.1 }
2972
2973 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1ref
|
2974 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jR)
2975 {
2976 CIMObjectPath *ref = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jR);
2977 CIMValue *cv = new CIMValue(*ref);
2978
2979 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
2980 schuur 1.1 }
2981
2982 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1datetime
|
2983 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jDT)
2984 {
2985 CIMDateTime *dt = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jDT);
2986 CIMValue *cv = new CIMValue(*dt);
2987
2988 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
2989 schuur 1.1 }
2990
2991 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMValue__1isArray
|
2992 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP)
2993 {
2994 CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jP);
2995
|
2996 schuur 1.1 return (jboolean)cv->isArray();
2997 }
2998
2999 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1boolean
|
3000 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jboolean jB)
3001 {
3002 CIMValue *cv = new CIMValue((Boolean)jB);
3003
3004 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
3005 schuur 1.1 }
3006
3007 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byteArray
|
3008 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jshortArray jshortA, jboolean notSigned)
3009 {
3010 CIMValue *cv = NULL;
3011 jboolean b;
3012 jsize len = jEnv->GetArrayLength(jshortA);
3013 jshort *jsA = jEnv->GetShortArrayElements(jshortA,&b);
3014
|
3015 schuur 1.1 if (notSigned) {
3016 Array<Uint8> u8;
3017 for (jsize i=0;i<len;i++)
3018 u8.append((Uint8)jsA[i]);
3019 cv=new CIMValue(u8);
3020 }
3021 else {
3022 Array<Sint8> s8;
3023 for (jsize i=0;i<len;i++)
3024 s8.append((Sint8)jsA[i]);
3025 cv=new CIMValue(s8);
3026 }
|
3027 mark.hamzy 1.20
3028 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
3029 schuur 1.1 }
3030
3031 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1shortArray
|
3032 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jintArray jintA, jboolean notSigned)
3033 {
3034 CIMValue *cv = NULL;
3035 jboolean b;
3036 jsize len = jEnv->GetArrayLength(jintA);
3037 jint *jiA = jEnv->GetIntArrayElements(jintA,&b);
3038
|
3039 schuur 1.1 if (notSigned) {
3040 Array<Uint16> u16;
3041 for (jsize i=0;i<len;i++)
3042 u16.append((Uint16)jiA[i]);
3043 cv=new CIMValue(u16);
3044 }
3045 else {
3046 Array<Sint16> s16;
3047 for (jsize i=0;i<len;i++)
3048 s16.append((Sint16)jiA[i]);
3049 cv=new CIMValue(s16);
3050 }
|
3051 mark.hamzy 1.20
3052 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
3053 schuur 1.1 }
3054
3055 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1intArray
|
3056 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned)
3057 {
3058 CIMValue *cv = NULL;
3059 jboolean b;
3060 jsize len = jEnv->GetArrayLength(jlongA);
3061 jlong *jlA = jEnv->GetLongArrayElements(jlongA,&b);
3062
|
3063 schuur 1.1 if (notSigned) {
3064 Array<Uint32> u32;
3065 for (jsize i=0;i<len;i++)
3066 u32.append((Uint32)jlA[i]);
3067 cv=new CIMValue(u32);
3068 }
3069 else {
3070 Array<Sint32> s32;
3071 for (jsize i=0;i<len;i++)
3072 s32.append((Sint32)jlA[i]);
3073 cv=new CIMValue(s32);
3074 }
|
3075 mark.hamzy 1.20
3076 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
3077 schuur 1.1 }
3078
3079 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1longArray
|
3080 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned)
3081 {
3082 CIMValue *cv = NULL;
3083 jboolean b;
3084 jsize len = jEnv->GetArrayLength(jlongA);
3085 jlong *jlA = jEnv->GetLongArrayElements(jlongA,&b);
3086
|
3087 schuur 1.1 if (notSigned) {
3088 Array<Uint64> u64;
3089 for (jsize i=0;i<len;i++)
3090 u64.append((Uint64)jlA[i]);
3091 cv=new CIMValue(u64);
3092 }
3093 else {
3094 Array<Sint64> s64;
3095 for (jsize i=0;i<len;i++)
3096 s64.append((Sint64)jlA[i]);
3097 cv=new CIMValue(s64);
3098 }
|
3099 mark.hamzy 1.20
3100 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
3101 schuur 1.1 }
3102
3103 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1stringArray
|
3104 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jobjectArray jstringA)
3105 {
3106 CIMValue *cv = NULL;
3107 jboolean b;
3108 jsize len = jEnv->GetArrayLength(jstringA);
|
3109 schuur 1.1 Array<String> strA;
3110
3111 for (jsize i=0;i<len;i++) {
3112 jstring jsA=(jstring)jEnv->GetObjectArrayElement(jstringA,i);
3113 const char *str=jEnv->GetStringUTFChars(jsA,NULL);
3114 strA.append(String(str));
3115 jEnv->ReleaseStringUTFChars(jsA,str);
3116 }
3117
3118 cv=new CIMValue(strA);
|
3119 mark.hamzy 1.20
3120 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
3121 schuur 1.1 }
3122
3123 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1booleanArray
|
3124 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jbooleanArray jboolA)
3125 {
3126 CIMValue *cv = NULL;
3127 jboolean b;
3128 jsize len = jEnv->GetArrayLength(jboolA);
3129 jboolean *jbA = jEnv->GetBooleanArrayElements(jboolA,&b);
3130 Array<Boolean> bA;
3131
|
3132 schuur 1.1 for (jsize i=0;i<len;i++)
3133 bA.append((Boolean)jbA[i]);
3134 cv=new CIMValue(bA);
|
3135 mark.hamzy 1.20
3136 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
3137 schuur 1.1 }
3138
3139 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1refArray
|
3140 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jintArray jintA)
3141 {
3142 CIMValue *cv = NULL;
3143 jboolean b;
3144 jsize len = jEnv->GetArrayLength(jintA);
3145 jint *jiA = jEnv->GetIntArrayElements(jintA,&b);
3146 Array<CIMObjectPath> cA;
3147
|
3148 schuur 1.1 for (jsize i=0;i<len;i++)
3149 cA.append(*((CIMObjectPath*)jiA[i]));
3150 cv=new CIMValue(cA);
|
3151 mark.hamzy 1.20
3152 return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
|
3153 schuur 1.1 }
3154
3155 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType
|
3156 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jP)
3157 {
3158 CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jP);
3159
3160 return DEBUG_ConvertCToJava (int, jint, pTypeToJType[cv->getType()]);
|
3161 schuur 1.1 }
3162
3163 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString
|
3164 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jV)
3165 {
3166 CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);
3167
|
3168 schuur 1.1 return (jstring)jEnv->NewStringUTF(cv->toString().getCString());
3169 }
3170
3171 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMValue__1getValue
|
3172 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jV)
3173 {
3174 CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);
3175
|
3176 schuur 1.1 if (cv->isNull())
3177 return NULL;
|
3178 mark.hamzy 1.20
|
3179 schuur 1.1 CIMType type=cv->getType();
3180
3181 if (!cv->isArray()) {
3182 switch (type) {
3183 case CIMTYPE_BOOLEAN:
3184 Boolean bo;
3185 cv->get(bo);
3186 return jEnv->NewObject(classRefs[1],instanceMethodIDs[1],bo);
3187 break;
3188 case CIMTYPE_SINT8:
3189 Sint8 s8;
3190 cv->get(s8);
3191 return jEnv->NewObject(classRefs[2],instanceMethodIDs[2],s8);
3192 break;
3193 case CIMTYPE_UINT8:
3194 Uint8 u8;
3195 cv->get(u8);
3196 return jEnv->NewObject(classRefs[8],instanceMethodIDs[8],u8);
3197 break;
3198 case CIMTYPE_SINT16:
3199 Sint16 s16;
3200 schuur 1.1 cv->get(s16);
3201 return jEnv->NewObject(classRefs[3],instanceMethodIDs[3],s16);
3202 break;
3203 case CIMTYPE_UINT16:
3204 Uint16 u16;
3205 cv->get(u16);
3206 return jEnv->NewObject(classRefs[9],instanceMethodIDs[9],u16);
3207 break;
3208 case CIMTYPE_SINT32:
3209 Sint32 s32;
3210 cv->get(s32);
3211 return jEnv->NewObject(classRefs[4],instanceMethodIDs[4],s32);
3212 break;
3213 case CIMTYPE_UINT32:
3214 Uint32 u32;
3215 cv->get(u32);
3216 return jEnv->NewObject(classRefs[10],instanceMethodIDs[10],u32);
3217 break;
3218 case CIMTYPE_SINT64:
3219 Sint64 s64;
3220 cv->get(s64);
3221 schuur 1.1 return jEnv->NewObject(classRefs[5],instanceMethodIDs[5],s64);
3222 break;
3223 case CIMTYPE_UINT64: {
3224 Uint64 u64;
3225 cv->get(u64);
3226 jobject big=jEnv->CallStaticObjectMethod(classRefs[14],staticMethodIDs[0],u64);
3227 return jEnv->NewObject(classRefs[11],instanceMethodIDs[11],big);
3228 }
3229 break;
3230 case CIMTYPE_REAL32:
3231 float f;
3232 cv->get(f);
3233 return jEnv->NewObject(classRefs[6],instanceMethodIDs[6],f);
3234 break;
3235 case CIMTYPE_REAL64:
3236 double d;
3237 cv->get(d);
3238 return jEnv->NewObject(classRefs[7],instanceMethodIDs[7],d);
3239 break;
3240 case CIMTYPE_STRING: {
3241 String s;
3242 schuur 1.1 jstring str;
3243 cv->get(s);
3244 str=jEnv->NewStringUTF(s.getCString());
3245 return str;
3246 }
3247 break;
3248 case CIMTYPE_REFERENCE: {
3249 CIMObjectPath ref;
3250 cv->get(ref);
|
3251 mark.hamzy 1.20 jint jOp = DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(ref));
3252 return jEnv->NewObject(classRefs[12],instanceMethodIDs[12],jOp);
|
3253 schuur 1.1 }
3254 break;
3255 case CIMTYPE_CHAR16:
3256 throwCIMException(jEnv,"+++ Char16 not yet supported");
3257 break;
3258 case CIMTYPE_DATETIME: {
3259 CIMDateTime dt;
3260 cv->get(dt);
|
3261 mark.hamzy 1.20 jint jDT = DEBUG_ConvertCToJava (CIMDateTime*, jint, new CIMDateTime(dt));
3262 return jEnv->NewObject(classRefs[24],instanceMethodIDs[35],jDT);
|
3263 schuur 1.1 }
3264 break;
|
3265 dave.sudlik 1.13 case CIMTYPE_OBJECT:
3266 throwCIMException(jEnv,"+++ Object not yet supported");
3267 break;
|
3268 schuur 1.1 default:
|
3269 mark.hamzy 1.17 throwCIMException(jEnv,"+++ unsupported type: ");
|
3270 schuur 1.1 }
3271 }
3272 else {
3273 switch (type) {
3274 case CIMTYPE_BOOLEAN: {
3275 Array<Boolean> bo;
3276 cv->get(bo);
3277 int s=bo.size();
3278 jobjectArray jbooleanA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[1],0);
|
3279 r.kieninger 1.11 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jbooleanA, i,
|
3280 schuur 1.1 jEnv->NewObject(classRefs[1],instanceMethodIDs[1],bo[i]));
3281 return jbooleanA;
3282 }
3283 break;
3284 case CIMTYPE_SINT8: {
3285 Array<Sint8> s8;
3286 cv->get(s8);
3287 int s=s8.size();
3288 jobjectArray jbyteA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[2],0);
|
3289 r.kieninger 1.11 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jbyteA, i,
|
3290 schuur 1.1 jEnv->NewObject(classRefs[2],instanceMethodIDs[2],s8[i]));
3291 return jbyteA;
3292 }
3293 break;
3294 case CIMTYPE_UINT8: {
3295 Array<Uint8> u8;
3296 cv->get(u8);
3297 int s=u8.size();
3298 jobjectArray jshortA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[8],0);
|
3299 r.kieninger 1.11 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jshortA, i,
|
3300 schuur 1.1 jEnv->NewObject(classRefs[8],instanceMethodIDs[8],u8[i]));
3301 return jshortA;
3302 }
3303 break;
3304 case CIMTYPE_SINT16: {
3305 Array<Sint16> s16;
3306 cv->get(s16);
3307 int s=s16.size();
3308 jobjectArray jshortA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[3],0);
|
3309 r.kieninger 1.11 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jshortA, i,
|
3310 schuur 1.1 jEnv->NewObject(classRefs[3],instanceMethodIDs[3],s16[i]));
3311 return jshortA;
3312 }
3313 break;
3314 case CIMTYPE_UINT16: {
3315 Array<Uint16> u16;
3316 cv->get(u16);
3317 int s=u16.size();
3318 jobjectArray jintA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[9],0);
|
3319 r.kieninger 1.11 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jintA, i,
|
3320 schuur 1.1 jEnv->NewObject(classRefs[9],instanceMethodIDs[9],u16[i]));
3321 return jintA;
3322 }
3323 break;
3324 case CIMTYPE_SINT32: {
3325 Array<Sint32> s32;
3326 cv->get(s32);
3327 int s=s32.size();
3328 jobjectArray jintA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[4],0);
|
3329 schuur 1.7 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jintA, i,
|
3330 schuur 1.1 jEnv->NewObject(classRefs[4],instanceMethodIDs[4],s32[i]));
3331 return jintA;
3332 }
3333 break;
3334 case CIMTYPE_UINT32: {
3335 Array<Uint32> u32;
3336 cv->get(u32);
3337 int s=u32.size();
3338 jobjectArray jlongA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[10],0);
|
3339 r.kieninger 1.11 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jlongA, i,
|
3340 schuur 1.1 jEnv->NewObject(classRefs[10],instanceMethodIDs[10],u32[i]));
3341 return jlongA;
3342 }
3343 break;
3344 case CIMTYPE_SINT64: {
3345 Array<Sint64> s64;
3346 cv->get(s64);
3347 int s=s64.size();
3348 jobjectArray jlongA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[5],0);
|
3349 r.kieninger 1.11 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jlongA, i,
|
3350 schuur 1.1 jEnv->NewObject(classRefs[5],instanceMethodIDs[5],s64[i]));
3351 return jlongA;
3352 }
3353 break;
3354 case CIMTYPE_UINT64:
3355 throwCIMException(jEnv,"+++ UnisgnetInt64 not yet supported");
3356 break;
3357 case CIMTYPE_REAL32: {
3358 Array<Real32> r32;
3359 cv->get(r32);
3360 int s=r32.size();
3361 jobjectArray jfloatA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[6],0);
|
3362 schuur 1.7 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jfloatA, i,
|
3363 schuur 1.1 jEnv->NewObject(classRefs[6],instanceMethodIDs[6],r32[i]));
3364 return jfloatA;
3365 }
3366 break;
3367 case CIMTYPE_REAL64: {
3368 Array<Real64> r64;
3369 cv->get(r64);
3370 int s=r64.size();
3371 jobjectArray jdoubleA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[7],0);
|
3372 r.kieninger 1.11 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jdoubleA, i,
|
3373 schuur 1.1 jEnv->NewObject(classRefs[7],instanceMethodIDs[7],r64[i]));
3374 return jdoubleA;
3375 }
3376 break;
3377 case CIMTYPE_STRING: {
3378 Array<String> str;
3379 cv->get(str);
3380 int s=str.size();
3381 jobjectArray jstringA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[22],0);
|
3382 r.kieninger 1.11 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jstringA, i,
|
3383 schuur 1.1 jEnv->NewStringUTF(str[i].getCString()));
3384 return jstringA;
3385 }
3386 break;
3387 case CIMTYPE_REFERENCE:
3388 throwCIMException(jEnv,"+++ Reference not yet supported");
3389 break;
3390 case CIMTYPE_CHAR16:
3391 throwCIMException(jEnv,"+++ Char16 not yet supported");
3392 break;
3393 case CIMTYPE_DATETIME:
3394 throwCIMException(jEnv,"+++ DateTime not yet supported");
3395 break;
|
3396 dave.sudlik 1.13 case CIMTYPE_OBJECT:
3397 throwCIMException(jEnv,"+++ Object not yet supported");
3398 break;
|
3399 schuur 1.1 default:
3400 throwCIMException(jEnv,"+++ unsupported type: ");
3401 }
3402 }
|
3403 mark.hamzy 1.20
|
3404 schuur 1.1 return NULL;
3405 }
3406
3407 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMValue__1finalize
|
3408 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jV)
3409 {
3410 CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);
3411
3412 delete cv;
3413
3414 DEBUG_ConvertCleanup (jint, jV);
|
3415 schuur 1.1 }
3416
3417 // -------------------------------------
3418 // ---
3419 // - CIMNameSpace
3420 // ---
3421 // -------------------------------------
3422
3423 _nameSpace::_nameSpace() {
3424 port_=0;
3425 hostName_=System::getHostName();
3426 nameSpace_="root/cimv2";
3427 }
3428
3429 _nameSpace::_nameSpace(String hn) {
3430 port_=0;
3431 hostName_=hn;
3432 nameSpace_="root/cimv2";
3433 }
3434
3435 _nameSpace::_nameSpace(String hn, String ns) {
3436 schuur 1.1 port_=0;
3437 hostName_=hn;
3438 nameSpace_=ns;
3439 }
3440
3441 int _nameSpace::port() {
3442 if (port_) return port_;
3443 port_=5988;
3444 if (hostName_.subString(0,7)=="http://") {
3445 protocol_="http://";
3446 hostName_=hostName_.subString(7);
3447 }
3448 Sint32 p=hostName_.reverseFind(':');
3449 if (p>=0) {
|
3450 kumpf 1.25 if ((hostName_[p+1] >= '0') && (hostName_[p+1] <= '9'))
|
3451 schuur 1.1 port_=atoi(hostName_.subString(p+1).getCString());
3452 hostName_.remove(p);
3453 }
3454 return port_;
3455 }
3456
3457 String _nameSpace::hostName() {
3458 port();
3459 return hostName_;
3460 }
3461
3462 String _nameSpace::nameSpace() {
3463 return nameSpace_;
3464 }
3465
3466
3467 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1new
|
3468 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs)
3469 {
3470 return DEBUG_ConvertCToJava (_nameSpace*, jint, new _nameSpace());
|
3471 schuur 1.1 }
3472
3473 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHn
|
3474 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jstring jHn)
3475 {
3476 const char *hn = jEnv->GetStringUTFChars(jHn,NULL);
3477 jint cInst = DEBUG_ConvertCToJava (_nameSpace*, jint, new _nameSpace(hn));
3478
|
3479 schuur 1.1 jEnv->ReleaseStringUTFChars(jHn,hn);
|
3480 mark.hamzy 1.20
|
3481 schuur 1.1 return cInst;
3482 }
3483
3484 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHnNs
|
3485 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jstring jHn, jstring jNs)
3486 {
3487 const char *hn = jEnv->GetStringUTFChars(jHn,NULL);
3488 const char *ns = jEnv->GetStringUTFChars(jNs,NULL);
3489 jint cInst = DEBUG_ConvertCToJava (_nameSpace*, jint, new _nameSpace(String(hn),String(ns)));
3490
|
3491 schuur 1.1 jEnv->ReleaseStringUTFChars(jHn,hn);
3492 jEnv->ReleaseStringUTFChars(jNs,ns);
|
3493 mark.hamzy 1.20
|
3494 schuur 1.1 return cInst;
3495 }
3496
3497 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getHost
|
3498 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jNs)
3499 {
3500 _nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);
3501 const String &hn = cNs->hostName_;
3502 jstring str = jEnv->NewStringUTF(hn.getCString());
3503
|
3504 schuur 1.1 return str;
3505 }
3506
3507 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getNameSpace
|
3508 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jNs)
3509 {
3510 _nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);
3511 const String &ns = cNs->nameSpace_;
3512 jstring str = jEnv->NewStringUTF(ns.getCString());
3513
|
3514 schuur 1.1 return str;
3515 }
3516
3517 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setHost
|
3518 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jNs, jstring jHn)
3519 {
3520 _nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);
3521 const char *str = jEnv->GetStringUTFChars(jHn,NULL);
3522
|
3523 schuur 1.1 cNs->port_=0;
3524 cNs->hostName_=str;
3525 jEnv->ReleaseStringUTFChars(jHn,str);
3526 }
3527
3528 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setNameSpace
|
3529 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jNs, jstring jN)
3530 {
|
3531 mark.hamzy 1.22 _nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);
|
3532 mark.hamzy 1.20 const char *str = jEnv->GetStringUTFChars(jN,NULL);
3533
|
3534 schuur 1.1 cNs->nameSpace_=str;
3535 jEnv->ReleaseStringUTFChars(jN,str);
3536 }
3537
|
3538 mark.hamzy 1.22 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1finalize
3539 (JNIEnv *jEnv, jobject jThs, jint jNs)
3540 {
3541 _nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);
3542
3543 delete cNs;
3544
3545 DEBUG_ConvertCleanup (jint, jNs);
3546 }
3547
|
3548 schuur 1.1 // -------------------------------------
3549 // ---
3550 // - Enumerators
3551 // ---
3552 // -------------------------------------
3553
|
3554 schuur 1.4 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1getClass
|
3555 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)
3556 {
3557 Array<CIMClass> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMClass>*, jEnum);
3558
3559 return DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass((*enm)[pos]));
|
3560 schuur 1.4 }
3561
3562 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1size
|
3563 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jEnum)
3564 {
3565 Array<CIMClass> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMClass>*, jEnum);
3566
|
3567 schuur 1.4 return enm->size();
3568 }
3569
|
3570 schuur 1.1
3571 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1getInstance
|
3572 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)
3573 {
3574 Array<CIMInstance> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMInstance>*, jEnum);
3575
3576 return DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance((*enm)[pos]));
|
3577 schuur 1.1 }
3578
3579 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1size
|
3580 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jEnum)
3581 {
3582 Array<CIMInstance> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMInstance>*, jEnum);
3583
|
3584 schuur 1.1 return enm->size();
3585 }
3586
|
3587 mark.hamzy 1.20 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1getObjectPath
3588 (JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)
3589 {
3590 Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMObjectPath>*, jEnum);
|
3591 schuur 1.1
|
3592 mark.hamzy 1.20 return DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath((*enm)[pos]));
|
3593 schuur 1.1 }
3594
3595 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1size
|
3596 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jEnum)
3597 {
3598 Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMObjectPath>*, jEnum);
3599
|
3600 schuur 1.1 return enm->size();
3601 }
3602
|
3603 schuur 1.5 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1getQualifierType
|
3604 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)
3605 {
3606 Array<CIMQualifierDecl> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMQualifierDecl>*, jEnum);
3607
3608 return DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, new CIMQualifierDecl((*enm)[pos]));
|
3609 schuur 1.5 }
3610
3611 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1size
|
3612 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jEnum)
3613 {
3614 Array<CIMQualifierDecl> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMQualifierDecl>*, jEnum);
3615
|
3616 schuur 1.5 return enm->size();
3617 }
3618
|
3619 schuur 1.1 // -------------------------------------
3620 // ---
3621 // - CIMClient
3622 // ---
3623 // -------------------------------------
3624
|
3625 schuur 1.5 void checkNs(CIMObjectPath *cop, jint jNs) {
3626 if (cop->getNameSpace().isNull()) {
3627 _nameSpace *ns=(_nameSpace*)jNs;
3628 cop->setNameSpace(CIMNamespaceName(ns->nameSpace()));
3629 }
3630 }
3631
|
3632 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1newNaUnPw
|
3633 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jNs, jstring jUn, jstring jPw)
3634 {
3635 _nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);
|
3636 schuur 1.5
|
3637 schuur 1.1 const char *un=jEnv->GetStringUTFChars(jUn,NULL);
3638 const char *pw=jEnv->GetStringUTFChars(jPw,NULL);
|
3639 schuur 1.5
|
3640 schuur 1.1 try {
|
3641 schuur 1.5 JMPIjvm::cacheIDs(jEnv);
|
3642 schuur 1.1 CIMClient *cc=new CIMClient();
3643 cc->connect(cNs->hostName(),cNs->port(),un,pw);
3644 jEnv->ReleaseStringUTFChars(jUn,un);
3645 jEnv->ReleaseStringUTFChars(jPw,pw);
|
3646 mark.hamzy 1.20 return DEBUG_ConvertCToJava (CIMClient*, jint, cc);
|
3647 schuur 1.1 }
|
3648 schuur 1.5 Catch(jEnv);
|
3649 schuur 1.1 return 0;
3650 }
3651
3652 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1disconnect
|
3653 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc)
3654 {
3655 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3656
|
3657 schuur 1.1 try {
3658 cCc->disconnect();
3659 }
|
3660 schuur 1.5 Catch(jEnv);
|
3661 schuur 1.1 }
|
3662 schuur 1.5
|
3663 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getClass
|
3664 schuur 1.6 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean lo,
|
3665 mark.hamzy 1.20 jboolean iq, jboolean ic, jobjectArray jPl)
3666 {
3667 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3668 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3669 CIMPropertyList pl=getList(jEnv,jPl);
3670
|
3671 schuur 1.1 try {
|
3672 schuur 1.5 checkNs(cop,jNs);
|
3673 schuur 1.6 CIMClass cls=cCc->getClass(cop->getNameSpace(),cop->getClassName(),(Boolean)lo,
3674 (Boolean)iq,(Boolean)ic,pl);
|
3675 mark.hamzy 1.20 return DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass(cls));
|
3676 schuur 1.1 }
|
3677 schuur 1.5 Catch(jEnv);
|
3678 mark.hamzy 1.20
|
3679 schuur 1.1 return 0;
3680 }
|
3681 schuur 1.3
3682 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteClass
|
3683 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop)
3684 {
3685 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3686 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3687
|
3688 schuur 1.3 try {
|
3689 schuur 1.5 checkNs(cop,jNs);
|
3690 schuur 1.3 cCc->deleteClass(cop->getNameSpace(),cop->getClassName());
3691 }
|
3692 schuur 1.5 Catch(jEnv);
|
3693 schuur 1.3 }
3694
3695 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createClass
|
3696 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, int jCl)
3697 {
3698 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3699 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3700 CIMClass *cl = DEBUG_ConvertJavaToC (jint, CIMClass*, jCl);
|
3701 schuur 1.3
3702 try {
3703 cCc->createClass(cop->getNameSpace(),*cl);
3704 }
|
3705 schuur 1.5 Catch(jEnv);
|
3706 schuur 1.3 }
3707
3708 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setClass
|
3709 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jCl)
3710 {
3711 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3712 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3713 CIMClass *cl = DEBUG_ConvertJavaToC (jint, CIMClass*, jCl);
|
3714 schuur 1.3
|
3715 schuur 1.1 try {
|
3716 schuur 1.5 checkNs(cop,jNs);
|
3717 schuur 1.3 cCc->modifyClass(cop->getNameSpace(),*cl);
|
3718 schuur 1.1 }
|
3719 schuur 1.5 Catch(jEnv);
|
3720 schuur 1.1 }
|
3721 schuur 1.3
3722 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClasses
|
3723 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, int jCop, jboolean deep, jboolean lo, jboolean iq, jboolean ic)
3724 {
3725 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3726 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3727
|
3728 schuur 1.1 try {
|
3729 schuur 1.5 checkNs(cop,jNs);
|
3730 schuur 1.3 Array<CIMClass> enm=cCc->enumerateClasses(
|
3731 schuur 1.6 cop->getNameSpace(),cop->getClassName(),(Boolean)deep,(Boolean)lo,(Boolean)iq,(Boolean)ic);
|
3732 mark.hamzy 1.20 return DEBUG_ConvertCToJava (Array<CIMClass>*, jint, new Array<CIMClass>(enm));
|
3733 schuur 1.1 }
|
3734 schuur 1.5 Catch(jEnv);
|
3735 mark.hamzy 1.20
|
3736 schuur 1.1 return 0;
3737 }
3738
|
3739 schuur 1.3 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClassNames
|
3740 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep)
3741 {
3742 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3743 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3744 CIMNamespaceName ns = cop->getNameSpace();
3745
|
3746 schuur 1.1 try {
|
3747 schuur 1.5 checkNs(cop,jNs);
|
3748 schuur 1.7 Array<CIMName> enm=cCc->enumerateClassNames(ns,cop->getClassName(),(Boolean)deep);
|
3749 schuur 1.3 Array<CIMObjectPath> *enmop=new Array<CIMObjectPath>();
3750 for (int i=0,m=enm.size(); i<m; i++) {
3751 enmop->append(CIMObjectPath(String::EMPTY,ns,enm[i]));
3752 }
|
3753 mark.hamzy 1.20 return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, enmop);
|
3754 schuur 1.3 }
|
3755 schuur 1.5 Catch(jEnv);
|
3756 mark.hamzy 1.20
|
3757 schuur 1.3 return 0;
3758 }
3759
|
3760 schuur 1.6 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateQualifiers
|
3761 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, int jCop)
3762 {
3763 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3764 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3765
|
3766 schuur 1.6 try {
3767 checkNs(cop,jNs);
|
3768 mark.hamzy 1.24
3769 Array<CIMQualifierDecl> enm=cCc->enumerateQualifiers(cop->getNameSpace());
3770
|
3771 mark.hamzy 1.20 return DEBUG_ConvertCToJava (Array<CIMQualifierDecl>*, jint, new Array<CIMQualifierDecl>(enm));
|
3772 schuur 1.6 }
3773 Catch(jEnv);
|
3774 mark.hamzy 1.20
|
3775 schuur 1.6 return 0;
3776 }
3777
|
3778 schuur 1.3 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getInstance
|
3779 schuur 1.6 (JNIEnv *jEnv, jobject jThs, jint jCc, int jNs, int jCop, jboolean lo,
|
3780 mark.hamzy 1.20 jboolean iq, jboolean ic, jobjectArray jPl)
3781 {
3782 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3783 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3784 CIMPropertyList pl = getList(jEnv,jPl);
|
3785 schuur 1.5
|
3786 schuur 1.3 try {
|
3787 schuur 1.5 checkNs(cop,jNs);
|
3788 mark.hamzy 1.24
3789 CIMInstance inst=cCc->getInstance(cop->getNameSpace(),
3790 *cop,
3791 (Boolean)lo,
3792 (Boolean)iq,
3793 (Boolean)ic,
3794 pl);
3795
|
3796 mark.hamzy 1.20 return DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance(inst));
|
3797 schuur 1.1 }
|
3798 schuur 1.5 Catch(jEnv);
|
3799 mark.hamzy 1.20
|
3800 schuur 1.1 return 0;
3801 }
3802
|
3803 schuur 1.3 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteInstance
|
3804 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop)
3805 {
3806 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3807 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3808
|
3809 schuur 1.3 try {
|
3810 schuur 1.5 checkNs(cop,jNs);
|
3811 schuur 1.3 cCc->deleteInstance(cop->getNameSpace(),*cop);
3812 }
|
3813 schuur 1.5 Catch(jEnv);
|
3814 schuur 1.3 }
3815
|
3816 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1createInstance
|
3817 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, int jCi)
3818 {
3819 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3820 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3821 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);
3822
|
3823 schuur 1.1 try {
|
3824 schuur 1.5 checkNs(cop,jNs);
|
3825 schuur 1.6 ci->setPath(*cop);
|
3826 schuur 1.1 CIMObjectPath obj=cCc->createInstance(cop->getNameSpace(),*ci);
|
3827 mark.hamzy 1.20 return DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(obj));
|
3828 schuur 1.1 }
|
3829 schuur 1.5 Catch(jEnv);
|
3830 mark.hamzy 1.20
|
3831 schuur 1.5 return 0;
|
3832 schuur 1.1 }
|
3833 schuur 1.3
|
3834 schuur 1.6 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1modifyInstance
3835 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jCi,
|
3836 mark.hamzy 1.20 jboolean iq, jobjectArray jPl)
3837 {
3838 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3839 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3840 CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);
3841 CIMPropertyList pl = getList(jEnv,jPl);
3842
|
3843 schuur 1.1 try {
|
3844 schuur 1.6 checkNs(cop,jNs);
3845 ci->setPath(*cop);
3846 cCc->modifyInstance(cop->getNameSpace(),*ci,(Boolean)iq,pl);
|
3847 schuur 1.1 }
|
3848 schuur 1.5 Catch(jEnv);
|
3849 schuur 1.3 }
3850
3851 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstances
|
3852 schuur 1.6 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep, jboolean lo,
|
3853 mark.hamzy 1.20 jboolean iq, jboolean ic, jobjectArray jPl)
3854 {
3855 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3856 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3857 CIMPropertyList pl = getList(jEnv,jPl);
3858
|
3859 schuur 1.3 try {
|
3860 schuur 1.5 checkNs(cop,jNs);
|
3861 schuur 1.6 CIMPropertyList props;
|
3862 schuur 1.3 Array<CIMInstance> enm=cCc->enumerateInstances(
|
3863 schuur 1.6 cop->getNameSpace(),cop->getClassName(),(Boolean)deep,(Boolean)lo,(Boolean)iq,(Boolean)ic,pl);
|
3864 mark.hamzy 1.20 return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, new Array<CIMInstance>(enm));
|
3865 schuur 1.3 }
|
3866 schuur 1.5 Catch(jEnv);
|
3867 mark.hamzy 1.20
|
3868 schuur 1.3 return 0;
3869 }
3870
3871 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstanceNames
|
3872 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep)
3873 {
3874 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3875 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3876
|
3877 schuur 1.3 try {
|
3878 schuur 1.5 checkNs(cop,jNs);
|
3879 schuur 1.3 Array<CIMObjectPath> enm=cCc->enumerateInstanceNames(
3880 cop->getNameSpace(),cop->getClassName()); //,(Boolean)deep);
|
3881 mark.hamzy 1.20 return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm));
|
3882 schuur 1.3 }
|
3883 schuur 1.5 Catch(jEnv);
|
3884 mark.hamzy 1.20
|
3885 schuur 1.5 return 0;
3886 }
3887
3888
3889 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getQualifier
|
3890 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop)
3891 {
3892 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3893 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3894
|
3895 schuur 1.5 try {
3896 checkNs(cop,jNs);
3897 CIMQualifierDecl *val=new CIMQualifierDecl(cCc->getQualifier(cop->getNameSpace(),cop->getClassName()));
|
3898 mark.hamzy 1.20 return DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, val);
|
3899 schuur 1.3 }
|
3900 schuur 1.5 Catch(jEnv);
|
3901 mark.hamzy 1.20
|
3902 schuur 1.3 return 0;
3903 }
3904
|
3905 schuur 1.5 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteQualifier
|
3906 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop)
3907 {
3908 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3909 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3910
|
3911 schuur 1.5 try {
3912 checkNs(cop,jNs);
3913 cCc->deleteQualifier(cop->getNameSpace(),cop->getClassName());
3914 }
3915 Catch(jEnv);
3916 }
3917
3918 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setQualifier
|
3919 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jQ)
3920 {
3921 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3922 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3923 CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ);
3924
|
3925 schuur 1.5 try {
3926 checkNs(cop,jNs);
3927 cCc->setQualifier(cop->getNameSpace(),*qt);
3928 }
3929 Catch(jEnv);
3930 }
3931
|
3932 schuur 1.1
3933 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty
|
3934 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn)
3935 {
3936 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3937 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3938 const char *str = jEnv->GetStringUTFChars(jPn,NULL);
3939 CIMName pName(str);
3940
|
3941 schuur 1.3 jEnv->ReleaseStringUTFChars(jPn,str);
3942 try {
|
3943 schuur 1.5 checkNs(cop,jNs);
|
3944 schuur 1.3 CIMValue *val=new CIMValue(cCc->getProperty(cop->getNameSpace(),*cop,pName));
|
3945 mark.hamzy 1.20 return DEBUG_ConvertCToJava (CIMValue*, jint, val);
|
3946 schuur 1.3 }
|
3947 schuur 1.5 Catch(jEnv);
|
3948 mark.hamzy 1.20
|
3949 schuur 1.3 return 0;
3950 }
|
3951 schuur 1.5
|
3952 schuur 1.1 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty
|
3953 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn, jint jV)
3954 {
3955 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3956 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
|
3957 mark.hamzy 1.22 CIMValue *val = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);
|
3958 mark.hamzy 1.20 const char *str = jEnv->GetStringUTFChars(jPn,NULL);
3959 CIMName pName(str);
3960
|
3961 schuur 1.3 jEnv->ReleaseStringUTFChars(jPn,str);
3962 try {
|
3963 schuur 1.5 checkNs(cop,jNs);
|
3964 schuur 1.3 cCc->setProperty(cop->getNameSpace(),*cop,pName,*val);
3965 }
|
3966 schuur 1.5 Catch(jEnv);
|
3967 schuur 1.3 }
3968
3969 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod
|
3970 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn, jobject jIn, jobject jOut)
3971 {
3972 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
3973 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
3974 const char *str = jEnv->GetStringUTFChars(jMn,NULL);
3975 CIMName method(str);
3976
|
3977 schuur 1.3 jEnv->ReleaseStringUTFChars(jMn,str);
3978
3979 Array<CIMParamValue> in;
3980 Array<CIMParamValue> out;
3981
|
3982 schuur 1.6 for (int i=0,m=jEnv->CallIntMethod(jIn,instanceMethodIDs[28]); i<m; i++) {
|
3983 schuur 1.3 JMPIjvm::checkException(jEnv);
|
3984 mark.hamzy 1.20
|
3985 schuur 1.6 jobject jProp=jEnv->CallObjectMethod(jIn,instanceMethodIDs[16],i);
|
3986 schuur 1.3 JMPIjvm::checkException(jEnv);
|
3987 mark.hamzy 1.20
3988 jint jp = jEnv->CallIntMethod(jProp,instanceMethodIDs[29]);
3989 CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp);
3990
|
3991 schuur 1.3 JMPIjvm::checkException(jEnv);
|
3992 mark.hamzy 1.20
|
3993 schuur 1.3 in.append(CIMParamValue(p->getName().getString(),p->getValue()));
3994 }
3995 try {
|
3996 schuur 1.5 checkNs(cop,jNs);
|
3997 schuur 1.3 CIMValue *val=new CIMValue(cCc->invokeMethod(cop->getNameSpace(),*cop,method,in,out));
3998
3999 for (int i=0,m=out.size(); i<m; i++) {
|
4000 mark.hamzy 1.20 const CIMParamValue &parm = out[i];
4001 const CIMValue v = parm.getValue();
4002 CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize());
4003 jint jp = DEBUG_ConvertCToJava (CIMProperty*, jint, p);
4004
4005 jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],jp);
4006
|
4007 schuur 1.6 jEnv->CallVoidMethod(jOut,instanceMethodIDs[15],prop);
|
4008 schuur 1.3 }
|
4009 mark.hamzy 1.20 return DEBUG_ConvertCToJava (CIMValue*, jint, val);
4010 }
|
4011 schuur 1.5 Catch(jEnv);
|
4012 mark.hamzy 1.20
|
4013 schuur 1.3 return 0;
4014 }
4015
|
4016 schuur 1.6 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod24
4017 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn,
|
4018 mark.hamzy 1.20 jobjectArray jIn, jobjectArray jOut)
4019 {
4020 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
4021 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
4022 const char *str = jEnv->GetStringUTFChars(jMn,NULL);
4023 CIMName method(str);
4024
|
4025 schuur 1.7 jEnv->ReleaseStringUTFChars(jMn,str);
4026
4027 Array<CIMParamValue> in;
4028 Array<CIMParamValue> out;
4029
4030 for (int i=0,m=jEnv->GetArrayLength(jIn); i<m; i++) {
4031 JMPIjvm::checkException(jEnv);
|
4032 mark.hamzy 1.20
|
4033 schuur 1.7 jobject jArg=jEnv->GetObjectArrayElement(jIn,i);
4034 JMPIjvm::checkException(jEnv);
|
4035 mark.hamzy 1.20
4036 jint jp = jEnv->CallIntMethod(jArg,instanceMethodIDs[39]);
4037 CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jp);
4038
|
4039 schuur 1.7 JMPIjvm::checkException(jEnv);
|
4040 mark.hamzy 1.20
|
4041 schuur 1.7 in.append(*p);
4042 }
4043 try {
4044 checkNs(cop,jNs);
4045 CIMValue *val=new CIMValue(cCc->invokeMethod(cop->getNameSpace(),*cop,method,in,out));
4046
4047 for (int i=0,m=out.size(),o=jEnv->GetArrayLength(jOut); i<m && i<o; i++) {
|
4048 mark.hamzy 1.24 CIMParamValue *parm = new CIMParamValue (out[i]);
4049 jint jParm = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);
4050
4051 jEnv->SetObjectArrayElement(jOut,
4052 i,
4053 jEnv->NewObject(classRefs[29],instanceMethodIDs[40],jParm));
|
4054 schuur 1.7 }
|
4055 mark.hamzy 1.20 return DEBUG_ConvertCToJava (CIMValue*, jint, val);
|
4056 schuur 1.7 }
4057 Catch(jEnv);
|
4058 mark.hamzy 1.20
|
4059 schuur 1.6 return 0;
4060 }
4061
|
4062 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery
|
4063 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jQuery, jstring jQl)
4064 {
4065 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
4066 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
4067 const char *str = jEnv->GetStringUTFChars(jQuery,NULL);
4068 String query(str);
|
4069 schuur 1.3
|
4070 mark.hamzy 1.16 /* Note:
4071 ** This does not work for some reason on the client java code:
|
4072 mark.hamzy 1.18 ** DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::Java_org_pegasus_jmpi_CIMClient__1execQuery: jEnv = "<<PEGASUS_STD(hex)<<(int)jEnv<<", jThs = "<<(int)jThs<<PEGASUS_STD(dec)<<", jCc = "<<jCc<<", jNs = "<<jNs<<", jCop = "<<jCop<<", jQuery = "<<PEGASUS_STD(hex)<<(int)jQuery<<", jQl = "<<(int)jQl<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
|
4073 mark.hamzy 1.16 ** What does work is:
4074 ** printf ("This is a test\n");
4075 */
4076
|
4077 schuur 1.3 jEnv->ReleaseStringUTFChars(jQuery,str);
|
4078 mark.hamzy 1.16
|
4079 schuur 1.3 str=jEnv->GetStringUTFChars(jQl,NULL);
4080 String ql(str);
|
4081 mark.hamzy 1.16
|
4082 schuur 1.3 jEnv->ReleaseStringUTFChars(jQl,str);
4083
4084 try {
|
4085 schuur 1.5 checkNs(cop,jNs);
|
4086 mark.hamzy 1.20 Array<CIMObject> enm=cCc->execQuery(cop->getNameSpace(),ql,query);
|
4087 schuur 1.3 Array<CIMInstance> *enmInst=new Array<CIMInstance>();
4088 for (int i=0,m=enm.size(); i<m; i++) {
4089 enmInst->append(CIMInstance(enm[i]));
4090 }
|
4091 mark.hamzy 1.20 return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);
|
4092 schuur 1.3 }
|
4093 schuur 1.5 Catch(jEnv);
|
4094 mark.hamzy 1.20
|
4095 schuur 1.3 return 0;
4096 }
4097
|
4098 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associatorNames
|
4099 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,
|
4100 mark.hamzy 1.20 jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole)
4101 {
4102 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
4103 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
4104 const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL);
4105 CIMName assocClass(str);
|
4106 schuur 1.3
4107 jEnv->ReleaseStringUTFChars(jAssocClass,str);
4108 str=jEnv->GetStringUTFChars(jResultClass,NULL);
|
4109 mark.hamzy 1.20
|
4110 schuur 1.3 CIMName resultClass(str);
|
4111 mark.hamzy 1.20
|
4112 schuur 1.3 jEnv->ReleaseStringUTFChars(jResultClass,str);
4113 str=jEnv->GetStringUTFChars(jRole,NULL);
|
4114 mark.hamzy 1.20
|
4115 schuur 1.3 String role(str);
|
4116 mark.hamzy 1.20
|
4117 schuur 1.3 jEnv->ReleaseStringUTFChars(jRole,str);
4118 str=jEnv->GetStringUTFChars(jResultRole,NULL);
|
4119 mark.hamzy 1.20
|
4120 schuur 1.3 String resultRole(str);
|
4121 mark.hamzy 1.20
|
4122 schuur 1.3 jEnv->ReleaseStringUTFChars(jResultRole,str);
4123
4124 try {
|
4125 schuur 1.5 checkNs(cop,jNs);
|
4126 schuur 1.3 Array<CIMObjectPath> enm=cCc->associatorNames(
4127 cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole);
|
4128 mark.hamzy 1.20 return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm));
|
4129 schuur 1.3 }
|
4130 schuur 1.5 Catch(jEnv);
|
4131 mark.hamzy 1.20
|
4132 schuur 1.3 return 0;
4133 }
4134
|
4135 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associators
|
4136 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,
|
4137 schuur 1.3 jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole,
|
4138 mark.hamzy 1.20 jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)
4139 {
4140 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
4141 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
4142 CIMPropertyList pl = getList(jEnv,jPl);
4143 const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL);
4144 CIMName assocClass(str);
|
4145 schuur 1.3
4146 jEnv->ReleaseStringUTFChars(jAssocClass,str);
4147 str=jEnv->GetStringUTFChars(jResultClass,NULL);
|
4148 mark.hamzy 1.20
|
4149 schuur 1.3 CIMName resultClass(str);
|
4150 mark.hamzy 1.20
|
4151 schuur 1.3 jEnv->ReleaseStringUTFChars(jResultClass,str);
4152 str=jEnv->GetStringUTFChars(jRole,NULL);
|
4153 mark.hamzy 1.20
|
4154 schuur 1.3 String role(str);
|
4155 mark.hamzy 1.20
|
4156 schuur 1.3 jEnv->ReleaseStringUTFChars(jRole,str);
4157 str=jEnv->GetStringUTFChars(jResultRole,NULL);
|
4158 mark.hamzy 1.20
|
4159 schuur 1.3 String resultRole(str);
|
4160 mark.hamzy 1.20
|
4161 schuur 1.3 jEnv->ReleaseStringUTFChars(jResultRole,str);
4162
4163 try {
|
4164 schuur 1.5 checkNs(cop,jNs);
|
4165 schuur 1.3 Array<CIMObject> enm=cCc->associators(
4166 cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole,
|
4167 mark.hamzy 1.17 (Boolean)includeQualifiers,(Boolean)includeClassOrigin,pl);
|
4168 schuur 1.3 Array<CIMInstance> *enmInst=new Array<CIMInstance>();
4169 for (int i=0,m=enm.size(); i<m; i++) {
4170 enmInst->append(CIMInstance(enm[i]));
4171 }
|
4172 mark.hamzy 1.20 return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);
|
4173 schuur 1.3 }
|
4174 schuur 1.5 Catch(jEnv);
|
4175 mark.hamzy 1.20
|
4176 schuur 1.3 return 0;
4177 }
4178
|
4179 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1referenceNames
|
4180 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,
|
4181 mark.hamzy 1.20 jstring jAssocClass, jstring jRole)
4182 {
4183 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
4184 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
4185 const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL);
4186 CIMName assocClass(str);
|
4187 schuur 1.3
4188 jEnv->ReleaseStringUTFChars(jAssocClass,str);
4189 str=jEnv->GetStringUTFChars(jRole,NULL);
|
4190 mark.hamzy 1.20
|
4191 schuur 1.3 String role(str);
|
4192 mark.hamzy 1.20
|
4193 schuur 1.3 jEnv->ReleaseStringUTFChars(jRole,str);
4194
4195 try {
|
4196 schuur 1.5 checkNs(cop,jNs);
|
4197 schuur 1.3 Array<CIMObjectPath> enm=cCc->referenceNames(
4198 cop->getNameSpace(),*cop,assocClass,role);
|
4199 mark.hamzy 1.20 return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm));
|
4200 schuur 1.3 }
|
4201 schuur 1.5 Catch(jEnv);
|
4202 mark.hamzy 1.20
|
4203 schuur 1.3 return 0;
4204 }
4205
|
4206 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1references
|
4207 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,
|
4208 schuur 1.3 jstring jAssocClass, jstring jRole,
|
4209 mark.hamzy 1.20 jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)
4210 {
4211 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
4212 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
4213 CIMPropertyList pl = getList(jEnv,jPl);
4214 const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL);
4215 CIMName assocClass(str);
|
4216 schuur 1.3
4217 jEnv->ReleaseStringUTFChars(jAssocClass,str);
4218 str=jEnv->GetStringUTFChars(jRole,NULL);
|
4219 mark.hamzy 1.20
|
4220 schuur 1.3 String role(str);
|
4221 mark.hamzy 1.20
|
4222 schuur 1.3 jEnv->ReleaseStringUTFChars(jRole,str);
4223
4224 try {
|
4225 schuur 1.5 checkNs(cop,jNs);
|
4226 schuur 1.3 Array<CIMObject> enm=cCc->references(
4227 cop->getNameSpace(),*cop,assocClass,role,
|
4228 mark.hamzy 1.17 (Boolean)includeQualifiers,(Boolean)includeClassOrigin,pl);
|
4229 schuur 1.3 Array<CIMInstance> *enmInst=new Array<CIMInstance>();
4230 for (int i=0,m=enm.size(); i<m; i++) {
4231 enmInst->append(CIMInstance(enm[i]));
4232 }
|
4233 mark.hamzy 1.20 return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);
|
4234 schuur 1.3 }
|
4235 schuur 1.5 Catch(jEnv);
|
4236 mark.hamzy 1.20
|
4237 schuur 1.5 return 0;
4238 }
4239
|
4240 schuur 1.6 static int normalizeNs(String &ns, String &nsBase, String &lastNsComp) {
4241 Uint32 n=ns.size();
4242 if (ns[n-1]=='/') {
4243 if (n>=2) ns=ns.subString(0,n-2);
4244 }
4245
4246 lastNsComp=ns;
4247 nsBase="root";
4248
4249 n=ns.reverseFind('/');
4250 if (n!=PEG_NOT_FOUND) {
4251 lastNsComp=ns.subString(n+1);
4252 nsBase=ns.subString(0,n);
4253 }
4254 return 0;
4255 }
4256
|
4257 schuur 1.5 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createNameSpace
|
4258 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jstring jNs)
4259 {
4260 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
4261 const char *str = jEnv->GetStringUTFChars(jNs,NULL);
4262 String ns(str);
|
4263 schuur 1.5
4264 jEnv->ReleaseStringUTFChars(jNs,str);
|
4265 schuur 1.6
4266 String lastNsComp;
4267 String nsBase;
4268
4269 normalizeNs(ns,nsBase,lastNsComp);
|
4270 schuur 1.5
4271 CIMInstance newInstance(CIMName("__Namespace"));
|
4272 schuur 1.6 newInstance.addProperty(CIMProperty(CIMName ("name"),lastNsComp));
|
4273 schuur 1.5
4274 try {
|
4275 schuur 1.6 cCc->createInstance(CIMNamespaceName(nsBase),newInstance);
|
4276 schuur 1.3 }
|
4277 schuur 1.5 Catch(jEnv);
4278 }
4279
4280 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateNameSpaces
|
4281 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jboolean deep, jobject jVec)
4282 {
4283 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
4284 CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
4285 String ns = cop->getNameSpace().getString();
|
4286 schuur 1.6
4287 try {
4288 Array<CIMObjectPath> enm=cCc->enumerateInstanceNames(
4289 cop->getNameSpace(),CIMName("__Namespace"));
4290 for (int i=0,s=enm.size(); i<s; i++) {
4291 CIMObjectPath &cop=enm[i];
4292 const Array<CIMKeyBinding>& kb=cop.getKeyBindings();
|
4293 mark.hamzy 1.17 const String &n=kb[0].getValue();
|
4294 mark.hamzy 1.16 if (!deep && n.find('/')!=PEG_NOT_FOUND)
4295 continue;
|
4296 mark.hamzy 1.17 String x=ns+"/"+n;
4297 jstring str=jEnv->NewStringUTF(x.getCString());
|
4298 schuur 1.6 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],str);
4299 }
4300 }
4301 Catch(jEnv);
|
4302 mark.hamzy 1.20
|
4303 schuur 1.5 return jVec;
4304 }
4305
4306 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteNameSpace
|
4307 mark.hamzy 1.20 (JNIEnv *jEnv, jobject jThs, jint jCc, jstring jNs)
4308 {
4309 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
4310 const char *str = jEnv->GetStringUTFChars(jNs,NULL);
4311 String ns(str);
|
4312 schuur 1.6
4313 jEnv->ReleaseStringUTFChars(jNs,str);
|
4314 mark.hamzy 1.20
|
4315 schuur 1.6 String lastNsComp;
4316 String nsBase;
4317
4318 normalizeNs(ns,nsBase,lastNsComp);
4319
4320 CIMObjectPath cop(String::EMPTY,CIMNamespaceName(nsBase),CIMName("__Namespace"));
4321 Array<CIMKeyBinding> kb;
4322 kb.append(CIMKeyBinding(("Name"),CIMValue(lastNsComp)));
4323 cop.setKeyBindings(kb);
4324
4325 try {
4326 cCc->deleteInstance(CIMNamespaceName(nsBase),cop);
4327 }
4328 Catch(jEnv);
|
4329 schuur 1.3 }
|
4330 schuur 1.1
|
4331 mark.hamzy 1.24 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1finalize
4332 (JNIEnv *jEnv, jobject jThs, jint jCc)
4333 {
4334 CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
4335
4336 delete cCc;
4337
4338 DEBUG_ConvertCleanup (jint, jCc);
4339 }
4340
|
4341 schuur 1.5 } // extern "C"
|
4342 schuur 1.1
4343 PEGASUS_NAMESPACE_END
|
Return to
JMPIImpl.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI