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