1 schuur 1.1 //%2003////////////////////////////////////////////////////////////////////////
2 //
3 // 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 // IBM Corp.; EMC Corporation, The Open Group.
7 //
8 // Permission is hereby granted, free of charge, to any person obtaining a copy
9 // of this software and associated documentation files (the "Software"), to
10 // deal in the Software without restriction, including without limitation the
11 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
12 // sell copies of the Software, and to permit persons to whom the Software is
13 // furnished to do so, subject to the following conditions:
14 //
15 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
16 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
17 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
18 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
19 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
20 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
21 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 schuur 1.1 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 //
24 //==============================================================================
25 //
26 // Author: Adrian Schuur, schuur@de.ibm.com
27 //
28 // Modified By: Adrian Dutta
29 // Andy Viciu
30 // Magda Vacarelu
31 //
32 //%/////////////////////////////////////////////////////////////////////////////
33
34
35 #include "JMPIImpl.h"
36
37 #include <dlfcn.h>
38 #include <iostream>
39
40 #include <Pegasus/Common/Config.h>
41 #include <Pegasus/Common/System.h>
42 #include <Pegasus/Common/CIMClass.h>
43 schuur 1.1 #include <Pegasus/Common/CIMInstance.h>
44 #include <Pegasus/Common/CIMObjectPath.h>
45 #include <Pegasus/Common/CIMProperty.h>
46 #include <Pegasus/Common/CIMType.h>
47 #include <Pegasus/Common/OperationContext.h>
48 #include <Pegasus/Provider/CIMOMHandle.h>
49 #include <Pegasus/Client/CIMClient.h>
|
50 schuur 1.3 #include <Pegasus/ProviderManager2/JMPI/JMPIProviderManager.h>
|
51 schuur 1.1
52 PEGASUS_USING_STD;
53 PEGASUS_NAMESPACE_BEGIN
54
55 JavaVM *JMPIjvm::jvm=NULL;
56 JvmVector JMPIjvm::jv;
|
57 schuur 1.2 int JMPIjvm::trace=0;
|
58 schuur 1.1
59 typedef struct {
60 int clsIndex;
61 const char * methodName;
62 const char * signature;
63 } METHOD_STRUCT;
64
65 const char* classNames[]={
66 "java/util/Vector" , // 0
67 "java/lang/Boolean", // 1
68 "java/lang/Byte", // 2
69 "java/lang/Short", // 3
70 "java/lang/Integer", // 4
71 "java/lang/Long", // 5
72 "java/lang/Float", // 6
73 "java/lang/Double", // 7
74 "org/pegasus/jmpi/UnsignedInt8", // 8
75 "org/pegasus/jmpi/UnsignedInt16", // 9
76 "org/pegasus/jmpi/UnsignedInt32", // 10
77 "org/pegasus/jmpi/UnsignedInt64", // 11
78 "org/pegasus/jmpi/CIMObjectPath", // 12
79 schuur 1.1 "org/pegasus/jmpi/CIMException", // 13
80 "java/math/BigInteger", // 14
81 "org/pegasus/jmpi/CIMProperty", // 15
82
83 "org/pegasus/jmpi/CIMOMHandle", // 16
84 "org/pegasus/jmpi/CIMClass", // 17
85 "org/pegasus/jmpi/CIMInstance", // 18
86 "org/pegasus/jmpi/CIMValue", // 19
|
87 schuur 1.3 "java/lang/Object", // 20
88 "java/lang/Throwable", // 21
89 "java/lang/String", // 22
|
90 schuur 1.1 "org/pegasus/jmpi/JarClassLoader", // 23
|
91 schuur 1.3 "org/pegasus/jmpi/CIMDateTime", // 24
92 "org/pegasus/jmpi/SelectExp", // 25
|
93 schuur 1.5 "org/pegasus/jmpi/CIMQualifier", // 26
94 "org/pegasus/jmpi/CIMQualifierType",// 27
95 "org/pegasus/jmpi/CIMFlavor", // 28
|
96 schuur 1.1 };
97
98
99 const METHOD_STRUCT instanceMethodNames[]={
|
100 schuur 1.3 /*00*/ { 0, "<init>", "()V" },
|
101 schuur 1.1 /*01*/ { 1, "<init>", "(Z)V" },
102 /*02*/ { 2, "<init>", "(B)V" },
103 /*03*/ { 3, "<init>", "(S)V" },
104 /*04*/ { 4, "<init>", "(I)V" },
105 /*05*/ { 5, "<init>", "(J)V" }, // ???
106 /*06*/ { 6, "<init>", "(F)V" },
107 /*07*/ { 7, "<init>", "(D)V" },
108 /*08*/ { 8, "<init>", "(S)V" },
109 /*09*/ { 9, "<init>", "(I)V" },
110 /*10*/ { 10,"<init>", "(J)V" },
111 /*11*/ { 11,"<init>", "(Ljava/math/BigInteger;)V" },
112 /*12*/ { 12,"<init>", "(I)V" },
113 /*13*/ { 13,"<init>", "(Ljava/lang/String;)V" },
114 /*14*/ { 15,"<init>", "(I)V" },
115 /*15*/ { 0, "addElement", "(Ljava/lang/Object;)V" },
116
117 /*16*/ { 0, "elementAt", "(I)Ljava/lang/Object;" },
|
118 schuur 1.3 /*17*/ { 16,"<init>", "(ILjava/lang/String;)V" },
|
119 schuur 1.1 /*18*/ { 13,"<init>", "(I)V" },
120 /*19*/ { 17,"<init>", "(I)V" },
121 /*20*/ { 18,"<init>", "(I)V" },
122 /*21*/ { 12,"<init>", "(I)V" },
123 /*22*/ { 12,"cInst", "()I" },
124 /*23*/ { 18,"cInst", "()I" },
125 /*24*/ { 17,"cInst", "()I" },
126 /*25*/ { 20,"toString", "()Ljava/lang/String;" },
127 /*26*/ { 21,"getMessage", "()Ljava/lang/String;" },
128 /*27*/ { 13,"getID", "()Ljava/lang/String;" },
129 /*28*/ { 0, "size", "()I" },
130 /*29*/ { 15,"cInst", "()I" },
131 /*30*/ { 16,"getClass", "(Lorg/pegasus/jmpi/CIMObjectPath;Z)Lorg/pegasus/jmpi/CIMClass;" },
132 /*31*/ { 0, "removeElementAt", "(I)V" },
133 /*32*/ { 19,"cInst", "()I" },
134 /*33*/ { 13,"<init>", "(ILjava/lang/String;)V" },
135 /*34*/ { 13,"getCode", "()I" },
136 /*35*/ { 12,"<init>", "(I)V" },
|
137 schuur 1.3 /*36*/ { 25,"<init>", "(I)V" },
|
138 schuur 1.5 /*37*/ { 26,"<init>", "(I)V" },
139 /*38*/ { 28,"<init>", "(I)V" },
140 /*38*/ { 28,"getFlavor", "()I" },
|
141 schuur 1.1 };
142
143 const METHOD_STRUCT staticMethodNames[]={
144 { 14, "valueOf", "(J)Ljava/math/BigInteger;" },
145 { 23, "load", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Class;" },
146 };
147
148
149 static int methodInitDone=0;
150
151 jclass classRefs[sizeof(classNames)/sizeof(char*)];
152 jmethodID instanceMethodIDs[sizeof(instanceMethodNames)/sizeof(METHOD_STRUCT)];
153 jmethodID staticMethodIDs[sizeof(staticMethodNames)/sizeof(METHOD_STRUCT)];
154 static jclass providerClassRef;
155
156 jclass JMPIjvm::getGlobalClassRef(JNIEnv *env, const char* name) {
157 jclass localRefCls=env->FindClass(name);
158 // if (env->ExceptionOccurred())
159 // env->ExceptionDescribe();
160 if (localRefCls==NULL) return JNI_FALSE;
161 jclass globalRefCls=(jclass) env->NewGlobalRef(localRefCls);
162 schuur 1.1 env->DeleteLocalRef(localRefCls);
163 return globalRefCls;
164 }
165
166 JMPIjvm::JMPIjvm() {
167 initJVM();
168 }
169
170 JMPIjvm::~JMPIjvm() {
171
172 }
173
174 int JMPIjvm::cacheIDs(JNIEnv *env) {
175 if (methodInitDone==1) return JNI_TRUE;
176 if (methodInitDone==-1) return JNI_FALSE;
177
178 methodInitDone=-1;
179 for (unsigned i=0; i<(sizeof(classNames)/sizeof(char*)); i++) {
180 // cerr<<"--- Trying "<< classNames[i]<<endl;
|
181 schuur 1.3 if ((classRefs[i]=getGlobalClassRef(env,classNames[i]))==NULL) return JNI_FALSE;
|
182 schuur 1.1 }
183
184 for (unsigned j=0; j<(sizeof(instanceMethodNames)/sizeof(METHOD_STRUCT)); j++) {
185 // cerr<<"--- Trying "<<j<<": "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<endl;
186 if ((instanceMethodIDs[j]=env->GetMethodID(
187 classRefs[instanceMethodNames[j].clsIndex],
188 instanceMethodNames[j].methodName,instanceMethodNames[j].signature))==NULL) return 0;
189 if ((instanceMethodIDs[j]=env->GetMethodID(classRefs[instanceMethodNames[j].clsIndex],instanceMethodNames[j].methodName,instanceMethodNames[j].signature))==NULL)
190 return 0;
191 }
192
193 for (unsigned k=0; k<(sizeof(staticMethodNames)/sizeof(METHOD_STRUCT)); k++) {
194 // cerr<<"--- Trying "<<k<<endl;
195 if ((staticMethodIDs[k]=env->GetStaticMethodID(
196 classRefs[staticMethodNames[k].clsIndex],
197 staticMethodNames[k].methodName,staticMethodNames[k].signature))==NULL) return 0;
198 }
199 // cerr<<"--- cacheIDs() done"<<endl;
200 methodInitDone=1;
201 return JNI_TRUE;
202 }
203 schuur 1.1
204 static void throwCIMException(JNIEnv *env,char *e) {
205 env->ThrowNew(classRefs[13],e);
206 }
207
|
208 schuur 1.3 int JMPIjvm::destroyJVM()
209 {
210 if (trace) cerr<<"--- JPIjvm::destroyJVM()\n";
211 #ifdef JAVA_DESTROY_VM_WORKS
212 if (jvm!=NULL) {
213 JvmVector *jv;
214 attachThread(&jv);
215 jvm->DestroyJavaVM();
216 jvm=NULL;
217 return 0;
218 }
219 #endif
220 return -1;
221 }
222
|
223 schuur 1.1 int JMPIjvm::initJVM()
224 {
225 JavaVMInitArgs vm_args;
226 JavaVMOption options[1];
227 jint res;
228 char *envcp;
229 char classpath[1024]="-Djava.class.path=";
230 JNIEnv *env;
231
|
232 schuur 1.2 if (getenv("JMPI_TRACE")) trace=1;
233 else trace=0;
234
235 if (trace) cerr<<"--- JPIjvm::initJVM()\n";
|
236 schuur 1.1 jv.initRc=0;
237
238 envcp=getenv("CLASSPATH");
239 if (envcp==NULL) {
240 jv.initRc=1;
|
241 schuur 1.2 cerr<<"--- jmpiJvm::initJVM(): No PEGASUS_PROVIDER_CLASSPATH environment variable found\n";
|
242 schuur 1.1 return -1;
243 }
244
245 strcat(classpath,envcp);
246 options[0].optionString=classpath;
247 vm_args.version=0x00010002;
248 vm_args.options=options;
249 vm_args.nOptions=1;
250 vm_args.ignoreUnrecognized=JNI_TRUE;
251
252 res=JNI_CreateJavaVM(&jvm,(void**)&env,&vm_args);
253 if (res!=0) {
254 fprintf(stderr,"Can not create Java VM\n");
255 exit(1);
256 }
257 jv.jvm=jvm;
258 jv.env=env;
259
260 if (cacheIDs(env)==1) {
261 jv.classRefs=classRefs;
262 jv.instMethodIDs=instanceMethodIDs;
263 schuur 1.1 }
264
265 if (env->ExceptionOccurred()) {
266 env->ExceptionDescribe();
267 exit(1);
268 }
269
270 return res;
271 }
272
273 JNIEnv* JMPIjvm::attachThread(JvmVector **jvp) {
274 JNIEnv* env;
275 if (jvm==NULL) initJVM();
276 jvm->AttachCurrentThread((void**)&env,NULL);
277 *jvp=&jv;
278 return env;
279 }
280
281 void JMPIjvm::detachThread() {
282 jvm->DetachCurrentThread();
283 }
284 schuur 1.1
285 jobject JMPIjvm::getProvider(JNIEnv *env, String jar, String cln,
286 const char *cn, jclass *cls)
287 {
288 static jobject gProv=NULL;
289 static jclass scls=NULL;
290 if (gProv) {
291 *cls=scls;
292 return gProv;
293 }
294
295 /*
|
296 schuur 1.2 cout<<"--- jar: "<<jar<<endl;
297 cout<<"--- cln: "<<cln<<endl;
|
298 schuur 1.1
299 jstring jjar=env->NewStringUTF((const char*)jar.getCString());
300 jstring jcln=env->NewStringUTF((const char*)cln.getCString());
301
302 jclass jcls=(jclass)env->CallStaticObjectMethod(classRefs[23],staticMethodIDs[1],
303 jjar,jcln);
304 if (env->ExceptionCheck()) {
305 env->ExceptionDescribe();
|
306 schuur 1.2 cerr<<"--- Unable to instantiate provider "<<cn<<endl;
|
307 schuur 1.1 // return NULL;
308 }
309 */
310
311 scls=getGlobalClassRef(env,(const char*)cln.getCString());
312 if (env->ExceptionCheck()) {
|
313 schuur 1.2 cerr<<"--- Provider "<<cn<<" not found"<<endl;
|
314 schuur 1.1 return NULL;
315 }
316 *cls=scls;
317
318 jmethodID id=env->GetMethodID(*cls,"<init>","()V");
319 jobject lProv=env->NewObject(*cls,id);
320 gProv=(jobject)env->NewGlobalRef(lProv);
321 if (env->ExceptionCheck()) {
|
322 schuur 1.2 cerr<<"--- Unable to instantiate provider "<<cn<<endl;
|
323 schuur 1.1 return NULL;
324 }
325 return gProv;
326 }
327
328 jobject JMPIjvm::getProvider(JNIEnv *env, const char *cn, jclass *cls)
329 {
330 static jobject gProv=NULL;
331 static jclass scls=NULL;
332 if (gProv) {
333 *cls=scls;
334 return gProv;
335 }
336
337 scls=getGlobalClassRef(env,cn);
338 if (env->ExceptionCheck()) {
|
339 schuur 1.2 cerr<<"--- Provider "<<cn<<" not found"<<endl;
|
340 schuur 1.1 return NULL;
341 }
342 *cls=scls;
343
344 jmethodID id=env->GetMethodID(*cls,"<init>","()V");
345 jobject lProv=env->NewObject(*cls,id);
346 gProv=(jobject)env->NewGlobalRef(lProv);
347 if (env->ExceptionCheck()) {
|
348 schuur 1.2 cerr<<"--- Unable to instantiate provider "<<cn<<endl;
|
349 schuur 1.1 return NULL;
350 }
351 return gProv;
352 }
353
354 void JMPIjvm::checkException(JNIEnv *env)
355 {
356 jstring msg=NULL,id=NULL;
357 int code;
358 const char *cp;
359 char hcp[512]="",hcp1[128];
360 String m=String::EMPTY;
361
362 if (env->ExceptionCheck()) {
363 jthrowable err=env->ExceptionOccurred();
|
364 schuur 1.2 if (trace)
365 env->ExceptionDescribe();
|
366 schuur 1.1 env->ExceptionClear();
367 if (err) {
368 msg=(jstring)env->CallObjectMethod(err,JMPIjvm::jv.ThrowableGetMessage);
369 code=(int)env->CallObjectMethod(err,JMPIjvm::jv.CIMExceptionGetCode);
370 id=(jstring)env->CallObjectMethod(err,JMPIjvm::jv.CIMExceptionGetID);
371 if (id) {
372 const char *cp=env->GetStringUTFChars(id,NULL);
373 strncpy(hcp1,cp,511);
374 env->ReleaseStringUTFChars(id,cp);
375 }
376
377 if (msg) {
378 const char *cp=env->GetStringUTFChars(msg,NULL);
379 strncpy(hcp,cp,511);
380 env->ReleaseStringUTFChars(msg,cp);
381 m=String(hcp);
|
382 schuur 1.2 }
383 if (trace)
384 cerr<<"--- throwing Pegasus exception: "<<hcp1<<" ("<<hcp<<") "<<endl;
|
385 schuur 1.1 throw CIMException((CIMStatusCode)code,m);
386 }
387 }
|
388 schuur 1.2 }
|
389 schuur 1.1
390 /**************************************************************************
391 * name - NewPlatformString
392 * description - Returns a new Java string object for the specified
393 * platform string.
394 * parameters - env
395 * s Platform encoded string
396 * returns - Java string object pointer or null (0)
397 **************************************************************************/
398 jstring JMPIjvm::NewPlatformString(JNIEnv *env, char *s)
399 {
400 size_t len = strlen(s);
401 jclass cls;
402 jmethodID mid;
403 jbyteArray ary;
404
405 NULL_CHECK0(cls = (*env).FindClass("java/lang/String"));
406 NULL_CHECK0(mid = (*env).GetMethodID(cls, "<init>", "([B)V"));
407 ary = (*env).NewByteArray((jsize)len);
408 if (ary != 0) {
409 jstring str = 0;
410 schuur 1.1 (*env).SetByteArrayRegion(ary, 0, (jsize)len,
411 (jbyte *)s);
412 if (!(*env).ExceptionOccurred()) {
413 str = (jstring)(*env).NewObject(cls, mid, ary);
414 }
415 (*env).DeleteLocalRef(ary);
416 return str;
417 }
418 return 0;
419 }
420
421
422 /**************************************************************************
423 * name - NewPlatformStringArray
424 * description - Returns a new array of Java string objects for the specified
425 * array of platform strings.
426 * parameters - env
427 * strv Platform encoded string array
428 * strc Number of strings in strv
429 * returns - Java string array object pointer
430 **************************************************************************/
431 schuur 1.1 jobjectArray JMPIjvm::NewPlatformStringArray(JNIEnv *env, char **strv, int strc)
432 {
433 jarray cls;
434 jarray ary;
435 int i;
436
437 NULL_CHECK0(cls = (jarray)(*env).FindClass("java/lang/String"));
438 NULL_CHECK0(ary = (*env).NewObjectArray(strc, (jclass)cls, 0));
439 for (i = 0; i < strc; i++) {
440 jstring str = NewPlatformString(env, *strv++);
441 NULL_CHECK0(str);
442 (*env).SetObjectArrayElement((jobjectArray)ary, i, str);
443 (*env).DeleteLocalRef(str);
444 }
445 return (jobjectArray)ary;
446 }
447
448
449
450
451
452 schuur 1.1 extern "C" {
453
454
455 void throwCimException(JNIEnv *jEnv, CIMException & e) {
456 JMPIjvm::cacheIDs(jEnv);
457 jobject ev=jEnv->NewObject(classRefs[13],instanceMethodIDs[18],(jint)e.getCode());
458 jEnv->Throw((jthrowable)ev);
459 }
460
461 void throwFailedException(JNIEnv *jEnv) {
462 JMPIjvm::cacheIDs(jEnv);
463 jobject ev=jEnv->NewObject(classRefs[13],instanceMethodIDs[18],1);
464 jEnv->Throw((jthrowable)ev);
465 }
466
467 void throwNotSupportedException(JNIEnv *jEnv) {
468 JMPIjvm::cacheIDs(jEnv);
469 jobject ev=jEnv->NewObject(classRefs[13],instanceMethodIDs[18],7);
470 jEnv->Throw((jthrowable)ev);
471 }
472
473 schuur 1.1
474 // -------------------------------------
475 // ---
476 // - CIMOMHandle
477 // ---
478 // -------------------------------------
479
480 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getClass
481 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean lo) {
482 CIMOMHandle *ch=(CIMOMHandle*)jCh;
483 CIMObjectPath *cop=(CIMObjectPath*)jCop;
484 OperationContext ctx;
485 try {
486 CIMClass cc=ch->getClass(ctx,cop->getNameSpace(),cop->getClassName(),
487 (Boolean)lo,
488 true,true,CIMPropertyList());
489 return (jint)new CIMClass(cc);
490 }
491 Catch(jEnv);
492 return 0;
493 }
494 schuur 1.1
495 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumClass
496 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean lo, jobject jVec) {
497 CIMOMHandle *ch=(CIMOMHandle*)jCh;
498 CIMObjectPath *cop=(CIMObjectPath*)jCop;
499 OperationContext ctx;
500 try {
501 Array<CIMClass> en=ch->enumerateClasses(ctx,cop->getNameSpace(),cop->getClassName(),
502 true,(Boolean)lo,true,true);
503 if (!cop->getClassName().isNull())
504 en.append(ch->getClass(ctx,cop->getNameSpace(),cop->getClassName(),(Boolean)lo,
505 true,true,CIMPropertyList()));
506 for (int i=0,m=en.size(); i<m; i++) {
507 CIMClass *cls=new CIMClass(en[i]);
508 jobject jCls=jEnv->NewObject(classRefs[17],instanceMethodIDs[19],(jint)cls);
509 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],jCls);
510 }
511 return;
512 }
513 Catch(jEnv);
514 return;
515 schuur 1.1 }
516
517 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getProperty
518 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jN) {
519
520 CIMOMHandle *ch=(CIMOMHandle*)jCh;
521 CIMObjectPath *cop=(CIMObjectPath*)jCop;
522 OperationContext ctx;
523 const char *str=jEnv->GetStringUTFChars(jN,NULL);
|
524 schuur 1.3
|
525 schuur 1.1 try {
526 CIMName prop(str);
527 CIMValue *cv = new CIMValue(ch->getProperty(ctx, cop->getNameSpace(),*cop,prop));
528 jEnv->ReleaseStringUTFChars(jN,str);
529 return (jint)(void*)cv;
530 }
531 Catch(jEnv);
532 return -1;
533 }
534
535 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance
536 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop) {
537
538 CIMOMHandle *ch=(CIMOMHandle*)jCh;
539 CIMObjectPath *cop=(CIMObjectPath*)jCop;
540 OperationContext ctx;
|
541 schuur 1.3
|
542 schuur 1.1 try {
543 ch->deleteInstance(ctx,cop->getNameSpace(),*cop);
544 }
545 Catch(jEnv);
546 }
547
548 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumInstances
549 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean jDeep, jboolean jLocalOnly, jobject jVec) {
550
551 CIMOMHandle *ch=(CIMOMHandle*)jCh;
552 CIMObjectPath *cop=(CIMObjectPath*)jCop;
553 OperationContext ctx;
|
554 schuur 1.3
|
555 schuur 1.1 try {
556 Array<CIMInstance> inst=ch->enumerateInstances(ctx,cop->getNameSpace(),cop->getClassName(),
557 (Boolean)jDeep,(Boolean)jLocalOnly,true,true,CIMPropertyList());
558 for (int i=0,s=inst.size(); i<s; i++){
559 CIMInstance *ci=new CIMInstance(inst[i]);
560 jobject jCi=jEnv->NewObject(classRefs[18],instanceMethodIDs[20],(jint)ci);
561 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],jCi);
562 }
563 }
564 Catch(jEnv);
565 }
566
567 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getInstance
|
568 schuur 1.3 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean jLocalOnly) {
|
569 schuur 1.1
570 CIMOMHandle *ch=(CIMOMHandle*)jCh;
571 CIMObjectPath *cop=(CIMObjectPath*)jCop;
572 OperationContext ctx;
|
573 schuur 1.3
|
574 schuur 1.1 try {
575 CIMInstance *inst=new CIMInstance(ch->getInstance(ctx,cop->getNameSpace(),*cop,
576 (Boolean)jLocalOnly,false,false,CIMPropertyList()));
577 return (jint)(void*)inst;
578 }
579 Catch(jEnv);
580 return -1;
581 }
582
|
583 schuur 1.3 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent
584 (JNIEnv *jEnv, jobject jThs, jint jCh, jstring jName, jstring jNs, jint jInd) {
585
586 CIMOMHandle *ch=(CIMOMHandle*)jCh;
587 CIMInstance *ind=(CIMInstance*)jInd;
|
588 schuur 1.1
|
589 schuur 1.3 const char *str=jEnv->GetStringUTFChars(jName,NULL);
590 String name(str);
591 jEnv->ReleaseStringUTFChars(jName,str);
592 str=jEnv->GetStringUTFChars(jNs,NULL);
593 String ns(str);
594 jEnv->ReleaseStringUTFChars(jNs,str);
595
596 JMPIProviderManager::indProvRecord *prec;
597 OperationContext* context;
598
599 if (JMPIProviderManager::provTab.lookup(name,prec)) {
600 if (prec->enabled) {
601 context=prec->ctx;
602 try {
603 prec->handler->deliver(*context, *ind);
604 }
605 Catch(jEnv);
606 }
607 }
608 else {
609 cout<<"_deliverEvent() "<<name<<" not found"<<endl;
610 schuur 1.3 }
611 }
|
612 schuur 1.1
613 // -------------------------------------
614 // ---
615 // - CIMClass
616 // ---
617 // -------------------------------------
618
619 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1newInstance
620 (JNIEnv *jEnv, jobject jThs, jint jCls) {
621 CIMClass *cls=(CIMClass*)jCls;
622 try {
623 CIMInstance *ci=new CIMInstance(cls->getClassName());
|
624 schuur 1.5 for (int i=0,m=cls->getQualifierCount(); i<m; i++) {
625 try {
626 ci->addQualifier(cls->getQualifier(i).clone());
627 }
628 catch (Exception e) {}
629 }
|
630 schuur 1.1 for (int i=0,m=cls->getPropertyCount(); i<m; i++) {
631 CIMProperty cp= cls->getProperty(i);
632 ci->addProperty(cp.clone());
|
633 schuur 1.5 for (int j=0, s=cp.getQualifierCount(); j<s; j++) {
634 try {
635 ci->getProperty(i).addQualifier(cp.getQualifier(j));
636 }
637 catch (Exception e) {}
638 }
|
639 schuur 1.1 }
640 return (jint)ci;
641 }
642 Catch(jEnv);
643 return 0;
644 }
645
646 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getName
647 (JNIEnv *jEnv, jobject jThs, jint jCls) {
648 CIMClass *cls=(CIMClass*)jCls;
649
650 try {
651 const String &cn=cls->getClassName().getString();
652 jstring str=jEnv->NewStringUTF(cn.getCString());
653 return str;
654 }
655 Catch(jEnv);
656 return 0;
657 }
658
659 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifier
660 schuur 1.1 (JNIEnv *jEnv, jobject jThs, jint jCls, jstring jN) {
661 CIMClass *cls=(CIMClass*)jCls;
662 const char *str=jEnv->GetStringUTFChars(jN,NULL);
663 jint rv=-1;
664 Uint32 pos=cls->findQualifier(String(str));
665 if (pos!=PEG_NOT_FOUND)
666 rv=(jint)new CIMQualifier(cls->getQualifier(pos));
667 jEnv->ReleaseStringUTFChars(jN,str);
668 return rv;
669 }
670
671 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperty
672 (JNIEnv *jEnv, jobject jThs, jint jCls, jstring jN) {
673 CIMClass *cls=(CIMClass*)jCls;
674 const char *str=jEnv->GetStringUTFChars(jN,NULL);
675 jint rv=-1;
676 Uint32 pos=cls->findProperty(CIMName(str));
677 if (pos!=PEG_NOT_FOUND)
678 rv=(jint)new CIMProperty(cls->getProperty(pos));
679 jEnv->ReleaseStringUTFChars(jN,str);
680 return rv;
681 schuur 1.1 }
682
683 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1hasQualifier
684 (JNIEnv *jEnv, jobject jThs, jint jCls, jstring jQ) {
685 CIMClass *cls=(CIMClass*)jCls;
686 const char *str=jEnv->GetStringUTFChars(jQ,NULL);
687 Uint32 pos=cls->findQualifier(String(str));
688 jEnv->ReleaseStringUTFChars(jQ,str);
689 return (jboolean)(pos!=PEG_NOT_FOUND);
690 }
691
692 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties
693 (JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) {
694 CIMClass *cls=(CIMClass*)jCls;
|
695 schuur 1.5
|
696 schuur 1.1 for (int i=0,s=cls->getPropertyCount(); i<s; i++) {
697 CIMProperty *cp=new CIMProperty(cls->getProperty(i));
698 jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)cp);
699 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop);
700 }
701 return jVec;
702 }
703
|
704 schuur 1.5 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1addProperty
705 (JNIEnv *jEnv, jobject jThs, jint jCls, jint jP) {
706 CIMClass *cls=(CIMClass*)jCls;
707 CIMProperty *p=(CIMProperty*)jP;
708 cls->addProperty(*p);
709 }
710
711 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1setProperties
712 (JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) {
713 CIMClass *cls=(CIMClass*)jCls;
714 for (int i=cls->getPropertyCount()-1; i>=0; i--) {
715 cls->removeProperty(i);
716 }
717 for (Uint32 i=0,s=jEnv->CallIntMethod(jVec,instanceMethodIDs[28]); i<s; i++) {
718 jobject o=jEnv->CallObjectMethod(jVec,instanceMethodIDs[16],(i));
719 CIMProperty *cp=(CIMProperty*)jEnv->CallIntMethod(o,instanceMethodIDs[29]);
720 cls->addProperty(*cp);
721 }
722 }
723
724
725 schuur 1.5 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifiers
726 (JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) {
727 CIMClass *cls=(CIMClass*)jCls;
728
729 for (int i=0,s=cls->getQualifierCount(); i<s; i++) {
730 CIMQualifier *cq=new CIMQualifier(cls->getQualifier(i));
731 jobject qual=jEnv->NewObject(classRefs[26],instanceMethodIDs[37],(jint)cq);
732 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],qual);
733 }
734 return jVec;
735 }
736
|
737 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1new
738 (JNIEnv *jEnv, jobject jThs, jstring jN) {
739 const char *str=jEnv->GetStringUTFChars(jN,NULL);
740 CIMClass *cls = new CIMClass(CIMName(str), CIMName());
741 jEnv->ReleaseStringUTFChars(jN,str);
742 return (jint)(void*)cls;
743 }
744
745 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getSuperClass
746 (JNIEnv *jEnv, jobject jThs, jint jCls) {
747 CIMClass *cls =(CIMClass *)jCls;
748 const String &cn=cls->getSuperClassName().getString();
749 jstring str=jEnv->NewStringUTF(cn.getCString());
750 return str;
751 }
752
753 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getKeys
754 (JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec){
755 CIMClass *cls=(CIMClass*)jCls;
756 if (cls->hasKeys()) {
757 Array<CIMName> keyNames;
758 schuur 1.1 cls->getKeyNames(keyNames);
759 for(int i=0, s=keyNames.size();i<s;i++){
760 Uint32 pos=cls->findProperty(keyNames[i]);
761 if (pos!=PEG_NOT_FOUND){
762 CIMProperty *cp=new CIMProperty(cls->getProperty(pos));
763 jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)cp);
764 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop);
765 }
766 }
767 }
768 return jVec;
769 }
770
771 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethod
772 (JNIEnv *jEnv, jobject jThs, jint jCls, jstring jN) {
773 CIMClass *cls=(CIMClass*)jCls;
774 const char *str=jEnv->GetStringUTFChars(jN,NULL);
775 jint rv=-1;
776 Uint32 pos=cls->findMethod(String(str));
777 if (pos!=PEG_NOT_FOUND) {
778 rv=(jint)new CIMMethod(cls->getMethod(pos));
779 schuur 1.1 }
780 jEnv->ReleaseStringUTFChars(jN,str);
781 return rv;
782 }
783
784 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1equals
785 (JNIEnv *jEnv, jobject jThs, jint jCls, jint jClsToBeCompared) {
786 CIMClass *cls = (CIMClass*)jCls;
787 CIMClass *clsToBeCompared = (CIMClass*)jClsToBeCompared;
788 return cls->identical(*clsToBeCompared);
789 }
790
791 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1finalize
792 (JNIEnv *jEnv, jobject jThs, jint jCls) {
793 CIMClass *cls=(CIMClass*)jCls;
794 delete cls;
795 }
796
797
798
799 // -------------------------------------
800 schuur 1.1 // ---
801 // - CIMInstance
802 // ---
803
804 // -------------------------------------
805 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1new
806 (JNIEnv *jEnv, jobject jThs) {
807 return (jint)new CIMInstance();
808 }
809
810 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1newCn
811 (JNIEnv *jEnv, jobject jThs, jstring jN) {
812 const char *str=jEnv->GetStringUTFChars(jN,NULL);
813 return (jint)new CIMInstance(CIMName(str));
814 }
815
816 //Added by Andy Viciu
817 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setName
818 (JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN) {
819 CIMInstance *ci=(CIMInstance*)jInst;
820 const char *str=jEnv->GetStringUTFChars(jN,NULL);
821 schuur 1.1 /* NOT SUPPORTED AND NOT NEEDED*/
822 }
823
824 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperty
825 (JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN, jint jV) {
826 CIMInstance *ci=(CIMInstance*)jInst;
827 CIMValue *cv=(CIMValue*)jV;
828 const char *str=jEnv->GetStringUTFChars(jN,NULL);
829 Uint32 pos=ci->findProperty(CIMName(str));
|
830 schuur 1.5 try {
|
831 schuur 1.1 if (pos!=PEG_NOT_FOUND) {
832 CIMProperty cp=ci->getProperty(pos);
833 if (cp.getType()==cv->getType())
834 cp.setValue(*cv);
835 else {
|
836 schuur 1.5 cerr<<"!!! CIMInstance.setProperty - Wrong type of CIMValue (instance name:"
837 <<ci->getClassName().getString()<<", property name: "<<str<<")";
838 cerr<<"!!! CIMInstance.setProperty : "<<cp.getType()<<" <> "<<cv->getType()<<endl;
|
839 schuur 1.1 throw CIMException(CIM_ERR_FAILED, String("Type mismatch"));
840 }
841 }
842 else {
843 CIMProperty *cp=new CIMProperty(CIMName(str),*cv);
844 ci->addProperty(*cp);
845 }
|
846 schuur 1.5 }
847 Catch(jEnv);
|
848 schuur 1.1
849 jEnv->ReleaseStringUTFChars(jN,str);
850 }
851
|
852 schuur 1.5 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperties
853 (JNIEnv *jEnv, jobject jThs, jint jInst, jobject jV) {
854 throw CIMException(CIM_ERR_NOT_SUPPORTED, String("Not yet supported"));
855 }
856
|
857 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperty
858 (JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN) {
859 CIMInstance *ci=(CIMInstance*)jInst;
860 const char *str=jEnv->GetStringUTFChars(jN,NULL);
861 jint rv=-1;
862 try {
863 Uint32 pos=ci->findProperty(CIMName(str));
864 if (pos!=PEG_NOT_FOUND) {
865 CIMProperty *cp=new CIMProperty(ci->getProperty(pos));
866 rv=(jint)cp;
867 }
868 }
869 Catch(jEnv);
870 jEnv->ReleaseStringUTFChars(jN,str);
871 return rv;
872 }
873
874 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getKeyValuePairs
875 (JNIEnv *jEnv, jobject jThs, jint jInst, jobject jVec) {
876 CIMInstance *ci=(CIMInstance*)jInst;
|
877 schuur 1.5
|
878 schuur 1.1 for (int i=0,s=ci->getPropertyCount(); i<s; i++) {
879 if (ci->getProperty(i).findQualifier(String("key"))!=PEG_NOT_FOUND) {
880 CIMProperty *cp=new CIMProperty(ci->getProperty(i));
881 jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)cp);
882 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop);
883 }
884 }
885
886 return jVec;
887 }
888
889 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMInstance__1getClassName
890 (JNIEnv *jEnv, jobject jThs, jint jInst) {
891 CIMInstance *ci=(CIMInstance*)jInst;
892 const String &cn=ci->getClassName().getString();
893 jstring str=jEnv->NewStringUTF(cn.getCString());
894 return str;
895 }
896
897 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getQualifier
898 (JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN) {
899 schuur 1.1 CIMInstance *ci=(CIMInstance*)jInst;
900 const char *str=jEnv->GetStringUTFChars(jN,NULL);
901 jint rv=-1;
902 Uint32 pos=ci->findQualifier(String(str));
903 if (pos!=PEG_NOT_FOUND) {
904 rv=(jint)new CIMQualifier(ci->getQualifier(pos));
905 }
906 jEnv->ReleaseStringUTFChars(jN,str);
907 return rv;
908 }
909
910 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1clone
911 (JNIEnv *jEnv, jobject jThs, jint jInst) {
912 CIMInstance *ci=(CIMInstance *)jInst;
913 CIMInstance* cl=new CIMInstance(ci->clone());
914 return (jint)(void*)cl;
915 }
916
917 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperties
918 (JNIEnv *jEnv, jobject jThs, jint jInst, jobject jVec) {
919 CIMInstance *ci=(CIMInstance*)jInst;
920 schuur 1.1 for (int i=0,s=ci->getPropertyCount(); i<s; i++) {
921 CIMProperty *cp=new CIMProperty(ci->getProperty(i));
922 jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)cp);
923 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop);
924 }
925 return jVec;
926 }
927
928 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1finalize
929 (JNIEnv *jEnv, jobject jThs, jint jInst) {
930 CIMInstance *ci=(CIMInstance*)jInst;
931 delete ci;
932 }
933
934
935 // -------------------------------------
936 // ---
937 // - CIMObjectPath
938 // ---
939 // -------------------------------------
940
941 schuur 1.1 CIMObjectPath* construct() {
942 CIMObjectPath *cop=new CIMObjectPath();
943 _nameSpace n;
944 cop->setNameSpace(n.nameSpace());
945 cop->setHost(n.hostName());
946 return cop;
947 }
948
949 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1new
950 (JNIEnv *jEnv, jobject jThs) {
951 return (jint)construct();
952 }
953
954 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCn
955 (JNIEnv *jEnv, jobject jThs, jstring jCn) {
956 CIMObjectPath *cop=construct();
957 const char *str=jEnv->GetStringUTFChars(jCn,NULL);
958 if (str) cop->setClassName(str);
959 jEnv->ReleaseStringUTFChars(jCn,str);
960 return (jint)(void*)cop;
961 }
962 schuur 1.1
963 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCnNs
964 (JNIEnv *jEnv, jobject jThs, jstring jCn, jstring jNs) {
965 CIMObjectPath *cop=construct();
966
967 const char *str1=jEnv->GetStringUTFChars(jCn,NULL);
968 const char *str2=jEnv->GetStringUTFChars(jNs,NULL);
969 try {
970 if (str1) cop->setClassName(str1);
971 if (str2) cop->setNameSpace(str2);
972 }
|
973 schuur 1.5 Catch(jEnv);
|
974 schuur 1.1
975 jEnv->ReleaseStringUTFChars(jCn,str1);
976 jEnv->ReleaseStringUTFChars(jNs,str2);
977 return (jint)(void*)cop;
978 }
979
980 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1_newCi
981 (JNIEnv *jEnv, jobject jThs, jint jInst) {
982 CIMInstance *ci = (CIMInstance *)jInst;
983 CIMObjectPath *cop=new CIMObjectPath(ci->getPath());
984 _nameSpace n;
985 if (cop->getNameSpace().isNull()) cop->setNameSpace(n.nameSpace());
986 if (cop->getHost()==NULL) cop->setHost(n.hostName());
987 return (jint)(void*)cop;
988 }
989
990 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1finalize
991 (JNIEnv *jEnv, jobject jThs, jint jCop) {
992 CIMObjectPath *cop=(CIMObjectPath*)jCop;
993 delete cop;
994 }
995 schuur 1.1
996 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getHost
997 (JNIEnv *jEnv, jobject jThs, jint jOp) {
998 CIMObjectPath *cop=(CIMObjectPath*)jOp;
999 const String &hn=cop->getHost();
1000 jstring str=jEnv->NewStringUTF(hn.getCString());
1001 return str;
1002 }
1003
1004 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setHost
1005 (JNIEnv *jEnv, jobject jThs, jint jOp, jstring jName) {
1006 CIMObjectPath *cop=(CIMObjectPath*)jOp;
1007 const char *str=jEnv->GetStringUTFChars(jName,NULL);
1008 cop->setHost(String(str));
1009 jEnv->ReleaseStringUTFChars(jName,str);
1010 }
1011
1012 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getObjectName
1013 (JNIEnv *jEnv, jobject jThs, jint jOp) {
1014 CIMObjectPath *cop=(CIMObjectPath*)jOp;
1015 const String &cn=cop->getClassName().getString();
1016 schuur 1.1 jstring str=jEnv->NewStringUTF(cn.getCString());
1017 return str;
1018 }
1019
1020 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setObjectName
1021 (JNIEnv *jEnv, jobject jThs, jint jOp, jstring jName) {
1022 CIMObjectPath *cop=(CIMObjectPath*)jOp;
1023 const char *str=jEnv->GetStringUTFChars(jName,NULL);
1024 cop->setClassName(String(str));
1025 jEnv->ReleaseStringUTFChars(jName,str);
1026 }
1027
1028 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getNameSpace
1029 (JNIEnv *jEnv, jobject jThs, jint jOp) {
1030 CIMObjectPath *cop=(CIMObjectPath*)jOp;
1031 const String &ns=cop->getNameSpace().getString();
1032 jstring str=jEnv->NewStringUTF(ns.getCString());
1033 return str;
1034 }
1035
1036 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setNameSpace
1037 schuur 1.1 (JNIEnv *jEnv, jobject jThs, jint jOp, jstring jName) {
1038 CIMObjectPath *cop=(CIMObjectPath*)jOp;
1039 const char *str=jEnv->GetStringUTFChars(jName,NULL);
1040 cop->setNameSpace(CIMNamespaceName(str));
1041 jEnv->ReleaseStringUTFChars(jName,str);
1042 }
1043
1044 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1addKey
1045 (JNIEnv *jEnv, jobject jThs, jint jOp, jstring jId, jint jVal) {
1046 CIMObjectPath *cop=(CIMObjectPath*)jOp;
1047 const char *str=jEnv->GetStringUTFChars(jId,NULL);
1048 CIMValue *cv=(CIMValue*)jVal;
1049 Array<CIMKeyBinding> keyBindings=cop->getKeyBindings();
1050 keyBindings.append(CIMKeyBinding(str,*cv));
1051 cop->setKeyBindings(Array<CIMKeyBinding>(keyBindings));
1052 jEnv->ReleaseStringUTFChars(jId,str);
1053 return;
1054 }
1055
1056 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeys
1057 (JNIEnv *jEnv, jobject jThs, jint jOp, jobject jVec) {
1058 schuur 1.1 CIMObjectPath *cop=(CIMObjectPath*)jOp;
1059 const Array<CIMKeyBinding> &akb=cop->getKeyBindings();
1060
1061 for (Uint32 i=0,s=akb.size(); i<s; i++) {
1062 const String &n=akb[i].getName().getString();
1063 const String &v=akb[i].getValue();
1064 CIMKeyBinding::Type t=akb[i].getType();
1065 CIMValue *cv;
1066 switch (t) {
1067 case CIMKeyBinding::NUMERIC:
1068 cv=new CIMValue((Sint32)atol(v.getCString()));
1069 break;
1070 case CIMKeyBinding::STRING:
1071 cv=new CIMValue(v);
1072 break;
1073 case CIMKeyBinding::BOOLEAN:
1074 cv=new CIMValue((Boolean)(v.getCString()));
1075 break;
1076 case CIMKeyBinding::REFERENCE:
1077 cv = new CIMValue(CIMObjectPath(akb[i].getValue()));
1078 break;
1079 schuur 1.1 default:
1080 throwCIMException(jEnv,"+++ unsupported type: ");
1081 }
1082
1083 CIMProperty *cp;
1084 if(t!=CIMKeyBinding::REFERENCE)
1085 cp=new CIMProperty(n,*cv);
1086 else cp=new CIMProperty(n,*cv, 0, ((CIMObjectPath) akb[i].getValue()).getClassName());
1087
1088 jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)cp);
1089 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop);
1090 }
1091 return jVec;
1092 }
1093
1094 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeyValue
1095 (JNIEnv *jEnv, jobject jThs, jint jOp, jstring jStr) {
1096 CIMObjectPath *cop=(CIMObjectPath*)jOp;
1097 const Array<CIMKeyBinding> &akb=cop->getKeyBindings();
1098 const char *strKeyName=jEnv->GetStringUTFChars(jStr,NULL);
1099 jstring retStr=NULL;
1100 schuur 1.1 for (Uint32 i=0,s=akb.size(); i<s; i++) {
1101 const String &n=akb[i].getName().getString();
1102 if (n==String(strKeyName)) {
1103 retStr=jEnv->NewStringUTF(akb[i].getValue().getCString());
1104 break;
1105 }
1106 }
1107 jEnv->ReleaseStringUTFChars(jStr,strKeyName);
1108 return retStr;
1109 }
1110
1111 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1set
1112 (JNIEnv *jEnv, jobject jThs, jstring jStr) {
1113 const char *strCop=jEnv->GetStringUTFChars(jStr,NULL);
1114 CIMObjectPath *cop=new CIMObjectPath();
1115 cop->set(String(strCop));
1116 jEnv->ReleaseStringUTFChars(jStr,strCop);
1117 return (jint)cop;
1118 }
1119
1120 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setKeys
1121 schuur 1.1 (JNIEnv *jEnv, jobject jThs, jint jOp, jobject jVec) {
1122 CIMObjectPath *cop=(CIMObjectPath*)jOp;
1123 Array<CIMKeyBinding> akb;
1124 for (Uint32 i=0,s=jEnv->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<s; i++) {
1125 jobject o=jEnv->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,(i));
1126 CIMProperty *cp=(CIMProperty*)jEnv->CallIntMethod(o,JMPIjvm::jv.PropertyCInst);
1127 akb.append(CIMKeyBinding(cp->getName(),cp->getValue()));
1128 }
1129 cop->setKeyBindings(akb);
1130 }
1131
1132 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1clone
1133 (JNIEnv *jEnv, jobject jThs, jint jOp) {
1134 CIMObjectPath *cop=(CIMObjectPath*)jOp;
1135 CIMObjectPath *copl=new CIMObjectPath(cop->getHost(), cop->getNameSpace(), cop->getClassName(), cop->getKeyBindings());
1136 return (jint)(void*)copl;
1137 }
1138
1139 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1toString
1140 (JNIEnv *jEnv, jobject jThs, jint jOp) {
1141 CIMObjectPath *cop=(CIMObjectPath*)jOp;
1142 schuur 1.1 const String &ns=cop->toString();
1143 jstring str=jEnv->NewStringUTF(ns.getCString());
1144 return str;
1145 }
1146
1147
1148 // -------------------------------------
1149 // ---
1150 // - CIMDataType
1151 // ---
1152 // -------------------------------------
1153
1154 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1new
1155 (JNIEnv *jEnv, jobject jThs, jint type) {
1156 return (jint)(void*) new _dataType(type);
1157 }
1158
1159 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newAr
1160 (JNIEnv *jEnv, jobject jThs, jint type, jint size) {
1161 return (jint)(void*) new _dataType(type,size);
1162 }
1163 schuur 1.1
1164 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newRef
1165 (JNIEnv *jEnv, jobject jThs, jint type, jstring jRef) {
1166 const char *ref=jEnv->GetStringUTFChars(jRef,NULL);
1167 jint cInst=(jint)(void*)new _dataType(type,String(ref));
1168 jEnv->ReleaseStringUTFChars(jRef,ref);
1169 return cInst;
1170 }
1171
1172 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isArray
1173 (JNIEnv *jEnv, jobject jThs, jint jDt) {
1174 _dataType *dt=(_dataType*)jDt;
1175 return dt->_array==true;
1176 }
1177
1178 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isreference
1179 (JNIEnv *jEnv, jobject jThs, jint jDt) {
1180 _dataType *dt=(_dataType*)jDt;
1181 return dt->_reference==true;
1182 }
1183
1184 schuur 1.1 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isReference
1185 (JNIEnv *jEnv, jobject jThs, jint jDt) {
1186 _dataType *dt=(_dataType*)jDt;
1187 return dt->_reference==true;
1188 }
1189
1190 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getType
1191 (JNIEnv *jEnv, jobject jThs, jint jDt) {
1192 _dataType *dt=(_dataType*)jDt;
1193 return dt->_type;
1194 }
1195
1196 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getSize
1197 (JNIEnv *jEnv, jobject jThs, jint jDt) {
1198 _dataType *dt=(_dataType*)jDt;
1199 return dt->_size;
1200 }
1201
1202 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1getRefClassName
1203 (JNIEnv *jEnv, jobject jThs, jint jDt) {
1204 _dataType *dt=(_dataType*)jDt;
1205 schuur 1.1 jstring str=jEnv->NewStringUTF(dt->_refClass.getCString());
1206 return str;
1207 }
1208
1209 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1toString
1210 (JNIEnv *jEnv, jobject jThs, jint jDt) {
1211 _dataType *dt=(_dataType*)jDt;
1212 jstring str=NULL;
1213 if (dt->_type & 0x10) {
1214 char tmp[32];
1215 strcpy(tmp,jTypeToChars[dt->_type-0x10]);
1216 strcat(tmp,"[]");
1217 str=jEnv->NewStringUTF(tmp);
|
1218 schuur 1.5 }
|
1219 schuur 1.1 else if (dt->_type & 0x20) {
1220 String tmp=dt->_refClass+" REF";
1221 str=jEnv->NewStringUTF(tmp.getCString());
1222 }
1223 else {
1224 str=jEnv->NewStringUTF(jTypeToChars[dt->_type]);
1225 }
1226 return str;
1227 }
1228
|
1229 schuur 1.5 CIMType toPtype(int jType) {
1230 if (jType>13) return (CIMType)14;
1231 return (CIMType)(jTypeToPType[jType]);
1232 }
|
1233 schuur 1.1
1234
1235 // -------------------------------------
1236 // ---
1237 // - CIMProperty
1238 // ---
1239 // -------------------------------------
1240
1241 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getValue
1242 (JNIEnv *jEnv, jobject jThs, jint jP) {
1243 CIMProperty *cp=(CIMProperty*)jP;
1244 CIMValue *cv=new CIMValue(cp->getValue());
1245 return (jint)cv;
1246 }
1247
|
1248 schuur 1.5 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1new
1249 (JNIEnv *jEnv, jobject jThs, jstring jN, jint jV) {
1250 CIMProperty *p=new CIMProperty(CIMName(),CIMValue());
1251 return (jint)p;
1252 }
1253
|
1254 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1property
1255 (JNIEnv *jEnv, jobject jThs, jstring jN, jint jV) {
1256 try {
1257 CIMValue *cv=(CIMValue*)jV;
1258 const char *str=jEnv->GetStringUTFChars(jN,NULL);
1259 CIMProperty *cp;
1260
1261 if (cv->getType()!=CIMTYPE_REFERENCE)
1262 cp=new CIMProperty(String(str),*cv);
1263 else {
1264 if (!cv->isArray()) {
1265 CIMObjectPath cop;
1266 cv->get(cop);
1267 cp=new CIMProperty(String(str),*cv,0, cop.getClassName());
1268 }
1269 else {
1270 throwCIMException(jEnv,"+++ unsupported type in CIMProperty.property");
1271 }
1272 }
1273
1274 jEnv->ReleaseStringUTFChars(jN,str);
1275 schuur 1.1 return (jint)cp;
1276 }
1277 Catch(jEnv);
1278 return -1;
1279 }
1280
1281 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setValue
1282 (JNIEnv *jEnv, jobject jThs, jint jP,jint jV) {
1283 CIMProperty *cp=(CIMProperty*)jP;
1284 CIMValue *cv=(CIMValue*)jV;
1285 cp->setValue(*cv);
1286 }
1287
1288 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isArray
1289 (JNIEnv *jEnv, jobject jThs, jint jP) {
1290 CIMProperty *cp=(CIMProperty*)jP;
1291 return (jboolean)cp->isArray();
1292 }
1293
1294 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addValue
1295 (JNIEnv *jEnv, jobject jThs, jint jP, jint jV) {
1296 schuur 1.1 CIMProperty *cp=(CIMProperty*)jP;
1297 CIMValue *cvin=(CIMValue*)jV;
1298 CIMValue cv=cp->getValue();
1299 if (cvin->isNull())
1300 throwCIMException(jEnv,"+++ null cvin value ");
1301 if (!cv.isArray())
1302 throwCIMException(jEnv,"+++ not an array ");
1303 if (cvin->getType()!=cv.getType())
1304 throwCIMException(jEnv,"+++ type mismatch ");
1305 CIMType type=cv.getType();
1306 switch (type) {
1307 case CIMTYPE_BOOLEAN: {
1308 Boolean bo;
1309 cvin->get(bo);
1310 Array<Boolean> boarr;
1311 cv.get(boarr);
1312 boarr.append(bo);
1313 }
1314 break;
1315 case CIMTYPE_UINT8: {
1316 Uint8 u8;
1317 schuur 1.1 cvin->get(u8);
1318 Array<Uint8> u8arr;
1319 cv.get(u8arr);
1320 u8arr.append(u8);
1321 }
1322 break;
1323 case CIMTYPE_SINT8: {
1324 Sint8 s8;
1325 cvin->get(s8);
1326 Array<Sint8> s8arr;
1327 cv.get(s8arr);
1328 s8arr.append(s8);
1329 }
1330 break;
1331 case CIMTYPE_UINT16: {
1332 Uint16 u16;
1333 cvin->get(u16);
1334 Array<Uint16> u16arr;
1335 cv.get(u16arr);
1336 u16arr.append(u16);
1337 }
1338 schuur 1.1 break;
1339 case CIMTYPE_SINT16: {
1340 Sint16 s16;
1341 cvin->get(s16);
1342 Array<Sint16> s16arr;
1343 cv.get(s16arr);
1344 s16arr.append(s16);
1345 }
1346 break;
1347 case CIMTYPE_UINT32: {
1348 Uint32 u32;
1349 cvin->get(u32);
1350 Array<Uint32> u32arr;
1351 cv.get(u32arr);
1352 u32arr.append(u32);
1353 }
1354 break;
1355 case CIMTYPE_SINT32: {
1356 Sint32 s32;
1357 cvin->get(s32);
1358 Array<Sint32> s32arr;
1359 schuur 1.1 cv.get(s32arr);
1360 s32arr.append(s32);
1361 }
1362 break;
1363 case CIMTYPE_UINT64: {
1364 Uint64 u64;
1365 cvin->get(u64);
1366 Array<Uint64> u64arr;
1367 cv.get(u64arr);
1368 u64arr.append(u64);
1369 }
1370 break;
1371 case CIMTYPE_SINT64: {
1372 Sint64 s64;
1373 cvin->get(s64);
1374 Array<Sint64> s64arr;
1375 cv.get(s64arr);
1376 s64arr.append(s64);
1377 }
1378 break;
1379 case CIMTYPE_REAL32: {
1380 schuur 1.1 Real32 f;
1381 cvin->get(f);
1382 Array<Real32> farr;
1383 cv.get(farr);
1384 farr.append(f);
1385 }
1386 break;
1387 case CIMTYPE_REAL64: {
1388 Real64 d;
1389 cvin->get(d);
1390 Array<Real64> darr;
1391 cv.get(darr);
1392 darr.append(d);
1393 }
1394 break;
1395 case CIMTYPE_STRING: {
1396 String str;
1397 cvin->get(str);
1398 Array<String> strarr;
1399 cv.get(strarr);
1400 strarr.append(str);
1401 schuur 1.1 }
1402 break;
1403 case CIMTYPE_REFERENCE: {
1404 CIMObjectPath ref;
1405 cvin->get(ref);
1406 Array<CIMObjectPath> refarr;
1407 cv.get(refarr);
1408 refarr.append(ref);
1409 }
1410 break;
1411 default:
1412 throwCIMException(jEnv,"+++ unsupported type ");
1413 }
1414 }
1415
|
1416 schuur 1.5 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addQualifier
1417 (JNIEnv *jEnv, jobject jThs, jint jP, jint jQ) {
1418 CIMProperty *cp=(CIMProperty*)jP;
1419 CIMQualifier *cq=(CIMQualifier*)jQ;
1420 cp->addQualifier(*cq);
1421 }
1422
|
1423 schuur 1.1 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getName
1424 (JNIEnv *jEnv, jobject jThs, jint jP) {
1425 CIMProperty *cp=(CIMProperty*)jP;
1426 const String &n=cp->getName().getString();
1427 jstring str=jEnv->NewStringUTF(n.getCString());
1428 return str;
1429 }
1430
|
1431 schuur 1.5 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setName
1432 (JNIEnv *jEnv, jobject jThs, jint jP, jstring jN) {
1433 CIMProperty *cp=(CIMProperty*)jP;
1434 const char *str=jEnv->GetStringUTFChars(jN,NULL);
1435 cp->setName(CIMName(str));
1436 jEnv->ReleaseStringUTFChars(jN,str);
1437 }
1438
|
1439 schuur 1.1 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isReference
1440 (JNIEnv *jEnv, jobject jThs, jint jP) {
1441 CIMProperty *cp=(CIMProperty*)jP;
1442 return (jboolean)(cp->getType()==CIMTYPE_REFERENCE);
1443 }
1444
1445 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getRefClassName
1446 (JNIEnv *jEnv, jobject jThs, jint jP) {
1447 CIMProperty *cp=(CIMProperty*)jP;
1448 const String &n=cp->getReferenceClassName().getString();
1449 jstring str=jEnv->NewStringUTF(n.getCString());
1450 return str;
1451 }
1452
1453 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getType
1454 (JNIEnv *jEnv, jobject jThs, jint jP) {
1455 CIMProperty *cp=(CIMProperty*)jP;
1456 String ref=cp->getReferenceClassName().getString();
1457 _dataType *type=new _dataType(pTypeToJType[cp->getType()],
1458 cp->getArraySize(),
1459 ref.size() ? true : false,
1460 schuur 1.1 false,
1461 cp->isArray(),
1462 ref,
1463 true);
1464 return (jint)type;
1465 }
1466
|
1467 schuur 1.5 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1setType
1468 (JNIEnv *jEnv, jobject jThs, jint jP, jint jDt) {
1469 CIMProperty *cp=(CIMProperty*)jP;
1470 _dataType *dt=(_dataType*)jDt;
1471 CIMValue val;
1472 val.setNullValue(toPtype(dt->_type),dt->_array);
1473 CIMProperty *np=new CIMProperty(cp->getName(),val);
1474 delete cp;
1475 return (jint)np;
1476 }
1477
|
1478 schuur 1.1 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMProperty__1getIdentifier
1479 (JNIEnv *jEnv, jobject jThs, jint jP) {
1480 CIMProperty *cp=(CIMProperty*)jP;
1481 const String &n=cp->getName().getString();
1482 jstring str=jEnv->NewStringUTF(n.getCString());
1483 return str;
1484 }
1485
1486 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1finalize
1487 (JNIEnv *jEnv, jobject jThs, jint jP) {
1488 CIMProperty *cp=(CIMProperty*)jP;
1489 delete cp;
1490 }
|
1491 schuur 1.5
1492
1493
1494 // -------------------------------------
1495 // ---
1496 // - CIMQualifierType
1497 // ---
1498 // -------------------------------------
1499
1500 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1new
1501 (JNIEnv *jEnv, jobject jThs) {
1502 CIMQualifierDecl *qual = new CIMQualifierDecl();
1503 return (jint)(void*)qual;
1504 }
1505
1506 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1finalize
1507 (JNIEnv *jEnv, jobject jThs, jint jQ) {
1508 CIMQualifierDecl *qt=(CIMQualifierDecl*)jQ;
1509 delete qt;
1510 }
1511
1512 schuur 1.5 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1getName
1513 (JNIEnv *jEnv, jobject jThs, jint jQ) {
1514 CIMQualifierDecl *qt=(CIMQualifierDecl*)jQ;
1515 const String &n=qt->getName().getString();
1516 jstring str=jEnv->NewStringUTF(n.getCString());
1517 return str;
1518 }
1519
1520 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setName
1521 (JNIEnv *jEnv, jobject jThs, jint jQ, jstring jN) {
1522 CIMQualifierDecl *qt=(CIMQualifierDecl*)jQ;
1523 const char *str=jEnv->GetStringUTFChars(jN,NULL);
1524 qt->setName(CIMName(str));
1525 jEnv->ReleaseStringUTFChars(jN,str);
1526 }
1527
1528 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setValue
1529 (JNIEnv *jEnv, jobject jThs, jint jQ,jint jV) {
1530 CIMQualifierDecl *qt=(CIMQualifierDecl*)jQ;
1531 CIMValue *cv=(CIMValue*)jV;
1532 qt->setValue(*cv);
1533 schuur 1.5 }
1534
1535
1536
|
1537 schuur 1.1
1538
1539 // -------------------------------------
1540 // ---
1541 // - CIMQualifier
1542 // ---
1543 // -------------------------------------
1544
|
1545 schuur 1.5 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifier__1new
1546 (JNIEnv *jEnv, jobject jThs, jstring jN) {
1547 const char *str=jEnv->GetStringUTFChars(jN,NULL);
1548 CIMQualifier *qual = new CIMQualifier(CIMName(str),CIMValue());
1549 jEnv->ReleaseStringUTFChars(jN,str);
1550 return (jint)(void*)qual;
1551 }
1552
|
1553 schuur 1.1 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1finalize
1554 (JNIEnv *jEnv, jobject jThs, jint jQ) {
1555 CIMQualifier *cq=(CIMQualifier*)jQ;
1556 delete cq;
1557 }
1558
|
1559 schuur 1.5 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getName
1560 (JNIEnv *jEnv, jobject jThs, jint jQ) {
1561 CIMQualifier *cq=(CIMQualifier*)jQ;
1562 const String &n=cq->getName().getString();
1563 jstring str=jEnv->NewStringUTF(n.getCString());
1564 return str;
1565 }
1566
1567 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getValue
1568 (JNIEnv *jEnv, jobject jThs, jint jQ) {
1569 CIMQualifier *cq=(CIMQualifier*)jQ;
1570 CIMValue *cv=new CIMValue(cq->getValue());
1571 return (jint)cv;
1572 }
1573
1574 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1setValue
1575 (JNIEnv *jEnv, jobject jThs, jint jQ,jint jV) {
1576 CIMQualifier *cq=(CIMQualifier*)jQ;
1577 CIMValue *cv=(CIMValue*)jV;
1578 cq->setValue(*cv);
1579 }
1580 schuur 1.5
|
1581 schuur 1.1
1582 // -------------------------------------
1583 // ---
1584 // - CIMDateTime
1585 // ---
1586 // -------------------------------------
1587
1588 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetime
1589 (JNIEnv *jEnv, jobject jThs, jstring jN) {
1590 const char *str=jEnv->GetStringUTFChars(jN,NULL);
1591 CIMDateTime *dt;
1592 if (strlen(str)==0)
1593 dt=new CIMDateTime();
1594 else
1595 dt=new CIMDateTime(String(str));
1596 jEnv->ReleaseStringUTFChars(jN,str);
1597 return (jint)dt;
1598 }
1599
1600 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetimeempty
1601 (JNIEnv *jEnv, jobject jThs) {
1602 schuur 1.1 CIMDateTime *dt=new CIMDateTime(CIMDateTime::getCurrentDateTime ());
1603 return (jint)dt;
1604 }
1605
1606 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1after
1607 (JNIEnv *jEnv, jobject jThs, jint jC, jint jD) {
1608 CIMDateTime *ct = (CIMDateTime *) jC;
1609 CIMDateTime *dt = (CIMDateTime *) jD;
1610 return (jboolean)(ct->getDifference(*ct, *dt)>0);
1611 }
1612
1613 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDateTime__1finalize
1614 (JNIEnv *jEnv, jobject jThs, jint jDT) {
1615 CIMDateTime *cdt = (CIMDateTime *) jDT;
1616 delete cdt;
1617 }
1618
1619
1620 // -------------------------------------
1621 // ---
1622 // - CIMMethod
1623 schuur 1.1 // ---
1624 // -------------------------------------
1625
1626 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1getType
1627 (JNIEnv *jEnv, jobject jThs, jint jM) {
1628 CIMMethod *cm=(CIMMethod*)jM;
1629 return (jint)cm->getType();
1630 }
1631
1632 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize
1633 (JNIEnv *jEnv, jobject jThs, jint jM) {
1634 CIMMethod *cm=(CIMMethod*)jM;
1635 delete cm;
1636 }
1637
1638
1639 // -------------------------------------
1640 // ---
1641 // - CIMValue
1642 // ---
1643 // -------------------------------------
1644 schuur 1.1
1645
1646 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byte
1647 (JNIEnv *jEnv, jobject jThs, jbyte jb, jboolean notSigned) {
1648 CIMValue *cv=NULL;
1649 if (notSigned) cv=new CIMValue((Uint8)jb);
1650 else cv=new CIMValue((Sint8)jb);
1651 return (jint)cv;
1652 }
1653
1654 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1short
1655 (JNIEnv *jEnv, jobject jThs, jshort js, jboolean notSigned) {
1656 CIMValue *cv=NULL;
1657 if (notSigned) cv=new CIMValue((Uint16)js);
1658 else cv=new CIMValue((Sint16)js);
1659 return (jint)cv;
1660 }
1661
1662 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue_makeInt
1663 (JNIEnv *jEnv, jobject jThs, jlong ji, jboolean notSigned) {
1664 CIMValue *cv=NULL;
1665 schuur 1.1 if (notSigned) cv=new CIMValue((Uint32)ji);
1666 else cv=new CIMValue((Sint32)ji);
1667 return (jint)cv;
1668 }
1669
1670 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1long
1671 (JNIEnv *jEnv, jobject jThs, jlong jl, jboolean notSigned) {
1672 CIMValue *cv=NULL;
1673 if (notSigned) cv=new CIMValue((Uint64)jl);
1674 else cv=new CIMValue((Sint64)jl);
1675 return (jint)cv;
1676 }
1677
1678 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1float
1679 (JNIEnv *jEnv, jobject jThs, jfloat jF) {
1680 CIMValue *cv=new CIMValue(jF);
1681 return (jint)cv;
1682 }
1683
1684 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1double
1685 (JNIEnv *jEnv, jobject jThs, jdouble jD) {
1686 schuur 1.1 CIMValue *cv=new CIMValue(jD);
1687 return (jint)cv;
1688 }
1689
1690 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1string
1691 (JNIEnv *jEnv, jobject jThs, jstring jS) {
1692 const char *str=jEnv->GetStringUTFChars(jS,NULL);
1693 CIMValue *cv=new CIMValue(String(str));
1694 jEnv->ReleaseStringUTFChars(jS,str);
1695 return (jint)cv;
1696 }
1697
1698 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1ref
1699 (JNIEnv *jEnv, jobject jThs, jint jR) {
1700 CIMObjectPath *ref=(CIMObjectPath*)jR;
1701 CIMValue *cv=new CIMValue(*ref);
1702 return (jint)cv;
1703 }
1704
1705 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1datetime
1706 (JNIEnv *jEnv, jobject jThs, jint jDT) {
1707 schuur 1.1 CIMDateTime *dt=(CIMDateTime*)jDT;
1708 CIMValue *cv=new CIMValue(*dt);
1709 return (jint)cv;
1710 }
1711
1712 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMValue__1isArray
1713 (JNIEnv *jEnv, jobject jThs, jint jP) {
1714 CIMValue *cv=(CIMValue*)jP;
1715 return (jboolean)cv->isArray();
1716 }
1717
1718 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1boolean
1719 (JNIEnv *jEnv, jobject jThs, jboolean jB) {
1720 CIMValue *cv=new CIMValue((Boolean)jB);
1721 return (jint)cv;
1722 }
1723
1724 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byteArray
1725 (JNIEnv *jEnv, jobject jThs, jshortArray jshortA, jboolean notSigned) {
1726 CIMValue *cv=NULL;
1727 jboolean b;
1728 schuur 1.1 jsize len=jEnv->GetArrayLength(jshortA);
1729 jshort* jsA=jEnv->GetShortArrayElements(jshortA,&b);
1730 if (notSigned) {
1731 Array<Uint8> u8;
1732 for (jsize i=0;i<len;i++)
1733 u8.append((Uint8)jsA[i]);
1734 cv=new CIMValue(u8);
1735 }
1736 else {
1737 Array<Sint8> s8;
1738 for (jsize i=0;i<len;i++)
1739 s8.append((Sint8)jsA[i]);
1740 cv=new CIMValue(s8);
1741 }
1742 return (jint)(void*)cv;
1743 }
1744
1745 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1shortArray
1746 (JNIEnv *jEnv, jobject jThs, jintArray jintA, jboolean notSigned) {
1747 CIMValue *cv=NULL;
1748 jboolean b;
1749 schuur 1.1 jsize len=jEnv->GetArrayLength(jintA);
1750 jint* jiA=jEnv->GetIntArrayElements(jintA,&b);
1751 if (notSigned) {
1752 Array<Uint16> u16;
1753 for (jsize i=0;i<len;i++)
1754 u16.append((Uint16)jiA[i]);
1755 cv=new CIMValue(u16);
1756 }
1757 else {
1758 Array<Sint16> s16;
1759 for (jsize i=0;i<len;i++)
1760 s16.append((Sint16)jiA[i]);
1761 cv=new CIMValue(s16);
1762 }
1763 return (jint)(void*)cv;
1764 }
1765
1766 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1intArray
1767 (JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned) {
1768 CIMValue *cv=NULL;
1769 jboolean b;
1770 schuur 1.1 jsize len=jEnv->GetArrayLength(jlongA);
1771 jlong* jlA=jEnv->GetLongArrayElements(jlongA,&b);
1772 if (notSigned) {
1773 Array<Uint32> u32;
1774 for (jsize i=0;i<len;i++)
1775 u32.append((Uint32)jlA[i]);
1776 cv=new CIMValue(u32);
1777 }
1778 else {
1779 Array<Sint32> s32;
1780 for (jsize i=0;i<len;i++)
1781 s32.append((Sint32)jlA[i]);
1782 cv=new CIMValue(s32);
1783 }
1784 return (jint)(void*)cv;
1785 }
1786
1787 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1longArray
1788 (JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned) {
1789 CIMValue *cv=NULL;
1790 jboolean b;
1791 schuur 1.1 jsize len=jEnv->GetArrayLength(jlongA);
1792 jlong* jlA=jEnv->GetLongArrayElements(jlongA,&b);
1793 if (notSigned) {
1794 Array<Uint64> u64;
1795 for (jsize i=0;i<len;i++)
1796 u64.append((Uint64)jlA[i]);
1797 cv=new CIMValue(u64);
1798 }
1799 else {
1800 Array<Sint64> s64;
1801 for (jsize i=0;i<len;i++)
1802 s64.append((Sint64)jlA[i]);
1803 cv=new CIMValue(s64);
1804 }
1805 return (jint)(void*)cv;
1806 }
1807
1808 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1stringArray
1809 (JNIEnv *jEnv, jobject jThs, jobjectArray jstringA) {
1810 CIMValue *cv=NULL;
1811 jboolean b;
1812 schuur 1.1 jsize len=jEnv->GetArrayLength(jstringA);
1813 Array<String> strA;
1814
1815 for (jsize i=0;i<len;i++) {
1816 jstring jsA=(jstring)jEnv->GetObjectArrayElement(jstringA,i);
1817 const char *str=jEnv->GetStringUTFChars(jsA,NULL);
1818 strA.append(String(str));
1819 jEnv->ReleaseStringUTFChars(jsA,str);
1820 }
1821
1822 cv=new CIMValue(strA);
1823 return (jint)(void*)cv;
1824 }
1825
1826 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1booleanArray
1827 (JNIEnv *jEnv, jobject jThs, jbooleanArray jboolA) {
1828 CIMValue *cv=NULL;
1829 jboolean b;
1830 jsize len=jEnv->GetArrayLength(jboolA);
1831 jboolean* jbA=jEnv->GetBooleanArrayElements(jboolA,&b);
1832 Array<Boolean> bA;
1833 schuur 1.1 for (jsize i=0;i<len;i++)
1834 bA.append((Boolean)jbA[i]);
1835 cv=new CIMValue(bA);
1836 return (jint)(void*)cv;
1837 }
1838
1839 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1refArray
1840 (JNIEnv *jEnv, jobject jThs, jintArray jintA) {
1841 CIMValue *cv=NULL;
1842 jboolean b;
1843 jsize len=jEnv->GetArrayLength(jintA);
1844 jint* jiA=jEnv->GetIntArrayElements(jintA,&b);
1845 Array<CIMObjectPath> cA;
1846 for (jsize i=0;i<len;i++)
1847 cA.append(*((CIMObjectPath*)jiA[i]));
1848 cv=new CIMValue(cA);
1849 return (jint)(void*)cv;
1850 }
1851
1852 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType
1853 (JNIEnv *jEnv, jobject jThs, jint jP) {
1854 schuur 1.1 CIMValue *cv=(CIMValue*)jP;
|
1855 schuur 1.5 return (jint)pTypeToJType[cv->getType()];
1856 // return (jint)cv->getType();
|
1857 schuur 1.1 }
1858
1859 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString
1860 (JNIEnv *jEnv, jobject jThs, jint jV) {
1861 CIMValue *cv=(CIMValue*)jV;
1862 return (jstring)jEnv->NewStringUTF(cv->toString().getCString());
1863 }
1864
1865 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMValue__1getValue
1866 (JNIEnv *jEnv, jobject jThs, jint jV) {
1867 CIMValue *cv=(CIMValue*)jV;
1868 if (cv->isNull())
1869 return NULL;
1870 CIMType type=cv->getType();
1871
1872 if (!cv->isArray()) {
1873 switch (type) {
1874 case CIMTYPE_BOOLEAN:
1875 Boolean bo;
1876 cv->get(bo);
1877 return jEnv->NewObject(classRefs[1],instanceMethodIDs[1],bo);
1878 schuur 1.1 break;
1879 case CIMTYPE_SINT8:
1880 Sint8 s8;
1881 cv->get(s8);
1882 return jEnv->NewObject(classRefs[2],instanceMethodIDs[2],s8);
1883 break;
1884 case CIMTYPE_UINT8:
1885 Uint8 u8;
1886 cv->get(u8);
1887 return jEnv->NewObject(classRefs[8],instanceMethodIDs[8],u8);
1888 break;
1889 case CIMTYPE_SINT16:
1890 Sint16 s16;
1891 cv->get(s16);
1892 return jEnv->NewObject(classRefs[3],instanceMethodIDs[3],s16);
1893 break;
1894 case CIMTYPE_UINT16:
1895 Uint16 u16;
1896 cv->get(u16);
1897 return jEnv->NewObject(classRefs[9],instanceMethodIDs[9],u16);
1898 break;
1899 schuur 1.1 case CIMTYPE_SINT32:
1900 Sint32 s32;
1901 cv->get(s32);
1902 return jEnv->NewObject(classRefs[4],instanceMethodIDs[4],s32);
1903 break;
1904 case CIMTYPE_UINT32:
1905 Uint32 u32;
1906 cv->get(u32);
1907 return jEnv->NewObject(classRefs[10],instanceMethodIDs[10],u32);
1908 break;
1909 case CIMTYPE_SINT64:
1910 Sint64 s64;
1911 cv->get(s64);
1912 return jEnv->NewObject(classRefs[5],instanceMethodIDs[5],s64);
1913 break;
1914 case CIMTYPE_UINT64: {
1915 Uint64 u64;
1916 cv->get(u64);
1917 jobject big=jEnv->CallStaticObjectMethod(classRefs[14],staticMethodIDs[0],u64);
1918 return jEnv->NewObject(classRefs[11],instanceMethodIDs[11],big);
1919 }
1920 schuur 1.1 break;
1921 case CIMTYPE_REAL32:
1922 float f;
1923 cv->get(f);
1924 return jEnv->NewObject(classRefs[6],instanceMethodIDs[6],f);
1925 break;
1926 case CIMTYPE_REAL64:
1927 double d;
1928 cv->get(d);
1929 return jEnv->NewObject(classRefs[7],instanceMethodIDs[7],d);
1930 break;
1931 case CIMTYPE_STRING: {
1932 String s;
1933 jstring str;
1934 cv->get(s);
1935 str=jEnv->NewStringUTF(s.getCString());
1936 return str;
1937 }
1938 break;
1939 case CIMTYPE_REFERENCE: {
1940 CIMObjectPath ref;
1941 schuur 1.1 cv->get(ref);
1942 return jEnv->NewObject(classRefs[12],instanceMethodIDs[12],
1943 (jint)new CIMObjectPath(ref));
1944 }
1945 break;
1946 case CIMTYPE_CHAR16:
1947 throwCIMException(jEnv,"+++ Char16 not yet supported");
1948 break;
1949 case CIMTYPE_DATETIME: {
1950 CIMDateTime dt;
1951 cv->get(dt);
1952 return jEnv->NewObject(classRefs[24],instanceMethodIDs[35],
1953 (jint)new CIMDateTime(dt));
1954 }
1955 // throwCIMException(jEnv,"+++ DateTime not yet supported");
1956 break;
1957 default:
1958 throwCIMException(jEnv,"+++ unsupported type: ");
1959 }
1960 }
1961
1962 schuur 1.1 else {
1963 switch (type) {
1964 case CIMTYPE_BOOLEAN: {
1965 Array<Boolean> bo;
1966 cv->get(bo);
1967 int s=bo.size();
1968 jobjectArray jbooleanA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[1],0);
1969 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jbooleanA, i,
1970 jEnv->NewObject(classRefs[1],instanceMethodIDs[1],bo[i]));
1971 return jbooleanA;
1972 }
1973 break;
1974 case CIMTYPE_SINT8: {
1975 Array<Sint8> s8;
1976 cv->get(s8);
1977 int s=s8.size();
1978 jobjectArray jbyteA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[2],0);
1979 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jbyteA, i,
1980 jEnv->NewObject(classRefs[2],instanceMethodIDs[2],s8[i]));
1981 return jbyteA;
1982 }
1983 schuur 1.1 break;
1984 case CIMTYPE_UINT8: {
1985 Array<Uint8> u8;
1986 cv->get(u8);
1987 int s=u8.size();
1988 jobjectArray jshortA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[8],0);
1989 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jshortA, i,
1990 jEnv->NewObject(classRefs[8],instanceMethodIDs[8],u8[i]));
1991 return jshortA;
1992 }
1993 break;
1994 case CIMTYPE_SINT16: {
1995 Array<Sint16> s16;
1996 cv->get(s16);
1997 int s=s16.size();
1998 jobjectArray jshortA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[3],0);
1999 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jshortA, i,
2000 jEnv->NewObject(classRefs[3],instanceMethodIDs[3],s16[i]));
2001 return jshortA;
2002 }
2003 break;
2004 schuur 1.1 case CIMTYPE_UINT16: {
2005 Array<Uint16> u16;
2006 cv->get(u16);
2007 int s=u16.size();
2008 jobjectArray jintA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[9],0);
2009 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jintA, i,
2010 jEnv->NewObject(classRefs[9],instanceMethodIDs[9],u16[i]));
2011 return jintA;
2012 }
2013 break;
2014 case CIMTYPE_SINT32: {
2015 Array<Sint32> s32;
2016 cv->get(s32);
2017 int s=s32.size();
2018 jobjectArray jintA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[4],0);
2019 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jintA, i,
2020 jEnv->NewObject(classRefs[4],instanceMethodIDs[4],s32[i]));
2021 return jintA;
2022 }
2023 break;
2024 case CIMTYPE_UINT32: {
2025 schuur 1.1 Array<Uint32> u32;
2026 cv->get(u32);
2027 int s=u32.size();
2028 jobjectArray jlongA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[10],0);
2029 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jlongA, i,
2030 jEnv->NewObject(classRefs[10],instanceMethodIDs[10],u32[i]));
2031 return jlongA;
2032 }
2033 break;
2034 case CIMTYPE_SINT64: {
2035 Array<Sint64> s64;
2036 cv->get(s64);
2037 int s=s64.size();
2038 jobjectArray jlongA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[5],0);
2039 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jlongA, i,
2040 jEnv->NewObject(classRefs[5],instanceMethodIDs[5],s64[i]));
2041 return jlongA;
2042 }
2043 break;
2044 case CIMTYPE_UINT64:
2045 throwCIMException(jEnv,"+++ UnisgnetInt64 not yet supported");
2046 schuur 1.1 break;
2047 case CIMTYPE_REAL32: {
2048 Array<Real32> r32;
2049 cv->get(r32);
2050 int s=r32.size();
2051 jobjectArray jfloatA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[6],0);
2052 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jfloatA, i,
2053 jEnv->NewObject(classRefs[6],instanceMethodIDs[6],r32[i]));
2054 return jfloatA;
2055 }
2056 break;
2057 case CIMTYPE_REAL64: {
2058 Array<Real64> r64;
2059 cv->get(r64);
2060 int s=r64.size();
2061 jobjectArray jdoubleA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[7],0);
2062 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jdoubleA, i,
2063 jEnv->NewObject(classRefs[7],instanceMethodIDs[7],r64[i]));
2064 return jdoubleA;
2065 }
2066 break;
2067 schuur 1.1 case CIMTYPE_STRING: {
2068 Array<String> str;
2069 cv->get(str);
2070 int s=str.size();
2071 jobjectArray jstringA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[22],0);
2072 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jstringA, i,
2073 jEnv->NewStringUTF(str[i].getCString()));
2074 return jstringA;
2075 }
2076 break;
2077 case CIMTYPE_REFERENCE:
2078 throwCIMException(jEnv,"+++ Reference not yet supported");
2079 break;
2080 case CIMTYPE_CHAR16:
2081 throwCIMException(jEnv,"+++ Char16 not yet supported");
2082 break;
2083 case CIMTYPE_DATETIME:
2084 throwCIMException(jEnv,"+++ DateTime not yet supported");
2085 break;
2086 default:
2087 throwCIMException(jEnv,"+++ unsupported type: ");
2088 schuur 1.1 }
2089 }
2090 return NULL;
2091 }
2092
2093 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMValue__1finalize
2094 (JNIEnv *jEnv, jobject jThs, jint jV) {
2095 CIMValue *cv=(CIMValue*)jV;
2096 delete cv;
2097 }
2098
2099
2100 // -------------------------------------
2101 // ---
2102 // - CIMNameSpace
2103 // ---
2104 // -------------------------------------
2105
2106 _nameSpace::_nameSpace() {
2107 port_=0;
2108 hostName_=System::getHostName();
2109 schuur 1.1 nameSpace_="root/cimv2";
2110 }
2111
2112 _nameSpace::_nameSpace(String hn) {
2113 port_=0;
2114 hostName_=hn;
2115 nameSpace_="root/cimv2";
2116 }
2117
2118 _nameSpace::_nameSpace(String hn, String ns) {
2119 port_=0;
2120 hostName_=hn;
2121 nameSpace_=ns;
2122 }
2123
2124 int _nameSpace::port() {
2125 if (port_) return port_;
2126 port_=5988;
2127 if (hostName_.subString(0,7)=="http://") {
2128 protocol_="http://";
2129 hostName_=hostName_.subString(7);
2130 schuur 1.1 }
2131 Sint32 p=hostName_.reverseFind(':');
2132 if (p>=0) {
2133 if (isdigit(hostName_[p+1]))
2134 port_=atoi(hostName_.subString(p+1).getCString());
2135 hostName_.remove(p);
2136 }
2137 return port_;
2138 }
2139
2140 String _nameSpace::hostName() {
2141 port();
2142 return hostName_;
2143 }
2144
2145 String _nameSpace::nameSpace() {
2146 return nameSpace_;
2147 }
2148
2149
2150 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1new
2151 schuur 1.1 (JNIEnv *jEnv, jobject jThs) {
2152 return (jint)(void*) new _nameSpace();
2153 }
2154
2155 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHn
2156 (JNIEnv *jEnv, jobject jThs, jstring jHn) {
2157 const char *hn=jEnv->GetStringUTFChars(jHn,NULL);
2158 jint cInst=(jint)(void*)new _nameSpace(hn);
2159 jEnv->ReleaseStringUTFChars(jHn,hn);
2160 return cInst;
2161 }
2162
2163 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHnNs
2164 (JNIEnv *jEnv, jobject jThs, jstring jHn, jstring jNs) {
2165 const char *hn=jEnv->GetStringUTFChars(jHn,NULL);
2166 const char *ns=jEnv->GetStringUTFChars(jNs,NULL);
2167 jint cInst=(jint)(void*)new _nameSpace(String(hn),String(ns));
2168 jEnv->ReleaseStringUTFChars(jHn,hn);
2169 jEnv->ReleaseStringUTFChars(jNs,ns);
2170 return cInst;
2171 }
2172 schuur 1.1
2173 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getHost
2174 (JNIEnv *jEnv, jobject jThs, jint jNs) {
2175 _nameSpace *cNs=(_nameSpace*)jNs;
2176 const String &hn=cNs->hostName_;
2177 jstring str=jEnv->NewStringUTF(hn.getCString());
2178 return str;
2179 }
2180
2181 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getNameSpace
2182 (JNIEnv *jEnv, jobject jThs, jint jNs) {
2183 _nameSpace *cNs=(_nameSpace*)jNs;
2184 const String &ns=cNs->nameSpace_;
2185 jstring str=jEnv->NewStringUTF(ns.getCString());
2186 return str;
2187 }
2188
2189 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setHost
2190 (JNIEnv *jEnv, jobject jThs, jint jNs, jstring jHn) {
2191 _nameSpace *cNs=(_nameSpace*)jNs;
2192 const char *str=jEnv->GetStringUTFChars(jHn,NULL);
2193 schuur 1.1 cNs->port_=0;
2194 cNs->hostName_=str;
2195 jEnv->ReleaseStringUTFChars(jHn,str);
2196 }
2197
2198 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setNameSpace
2199 (JNIEnv *jEnv, jobject jThs, jint jNs, jstring jN) {
2200 _nameSpace *cNs=(_nameSpace*)jN;
2201 const char *str=jEnv->GetStringUTFChars(jN,NULL);
2202 cNs->nameSpace_=str;
2203 jEnv->ReleaseStringUTFChars(jN,str);
2204 }
2205
2206
2207 // -------------------------------------
2208 // ---
2209 // - Enumerators
2210 // ---
2211 // -------------------------------------
2212
|
2213 schuur 1.4 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1getClass
2214 (JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) {
2215 Array<CIMClass> *enm=(Array<CIMClass>*)jEnum;
2216 return (jint) new CIMClass((*enm)[pos]);
2217 }
2218
2219 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1size
2220 (JNIEnv *jEnv, jobject jThs, jint jEnum) {
2221 Array<CIMClass> *enm=(Array<CIMClass>*)jEnum;
2222 return enm->size();
2223 }
2224
|
2225 schuur 1.1
2226 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1getInstance
2227 (JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) {
2228 Array<CIMInstance> *enm=(Array<CIMInstance>*)jEnum;
2229 return (jint) new CIMInstance((*enm)[pos]);
2230 }
2231
2232 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1size
2233 (JNIEnv *jEnv, jobject jThs, jint jEnum) {
2234 Array<CIMInstance> *enm=(Array<CIMInstance>*)jEnum;
2235 return enm->size();
2236 }
2237
2238
2239 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1getObjectPath
2240 (JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) {
2241 Array<CIMObjectPath> *enm=(Array<CIMObjectPath>*)jEnum;
2242 return (jint) new CIMObjectPath((*enm)[pos]);
2243 }
2244
2245 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1size
2246 schuur 1.1 (JNIEnv *jEnv, jobject jThs, jint jEnum) {
2247 Array<CIMObjectPath> *enm=(Array<CIMObjectPath>*)jEnum;
2248 return enm->size();
2249 }
2250
|
2251 schuur 1.5 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1getQualifierType
2252 (JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) {
2253 Array<CIMQualifierDecl> *enm=(Array<CIMQualifierDecl>*)jEnum;
2254 return (jint) new CIMQualifierDecl((*enm)[pos]);
2255 }
2256
2257 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1size
2258 (JNIEnv *jEnv, jobject jThs, jint jEnum) {
2259 Array<CIMQualifierDecl> *enm=(Array<CIMQualifierDecl>*)jEnum;
2260 return enm->size();
2261 }
2262
|
2263 schuur 1.1 // -------------------------------------
2264 // ---
2265 // - CIMClient
2266 // ---
2267 // -------------------------------------
2268
|
2269 schuur 1.5 void checkNs(CIMObjectPath *cop, jint jNs) {
2270 if (cop->getNameSpace().isNull()) {
2271 _nameSpace *ns=(_nameSpace*)jNs;
2272 cop->setNameSpace(CIMNamespaceName(ns->nameSpace()));
2273 }
2274 }
2275
|
2276 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1newNaUnPw
2277 (JNIEnv *jEnv, jobject jThs, jint jNs, jstring jUn, jstring jPw) {
2278 _nameSpace *cNs=(_nameSpace*)jNs;
|
2279 schuur 1.5
|
2280 schuur 1.1 const char *un=jEnv->GetStringUTFChars(jUn,NULL);
2281 const char *pw=jEnv->GetStringUTFChars(jPw,NULL);
|
2282 schuur 1.5
|
2283 schuur 1.1 try {
|
2284 schuur 1.5 JMPIjvm::cacheIDs(jEnv);
|
2285 schuur 1.1 CIMClient *cc=new CIMClient();
2286 cc->connect(cNs->hostName(),cNs->port(),un,pw);
2287 jEnv->ReleaseStringUTFChars(jUn,un);
2288 jEnv->ReleaseStringUTFChars(jPw,pw);
2289 return (jint)(void*)cc;
2290 }
|
2291 schuur 1.5 Catch(jEnv);
|
2292 schuur 1.1 return 0;
2293 }
2294
2295 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1disconnect
2296 (JNIEnv *jEnv, jobject jThs, jint jCc) {
2297 CIMClient *cCc=(CIMClient*)jCc;
2298 try {
2299 cCc->disconnect();
2300 }
|
2301 schuur 1.5 Catch(jEnv);
|
2302 schuur 1.1 }
|
2303 schuur 1.5
|
2304 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getClass
|
2305 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean lo) {
|
2306 schuur 1.1 CIMClient *cCc=(CIMClient*)jCc;
2307 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2308 try {
|
2309 schuur 1.5 checkNs(cop,jNs);
|
2310 schuur 1.1 CIMClass cls=cCc->getClass(cop->getNameSpace(),cop->getClassName(),(Boolean)lo);
|
2311 schuur 1.3 return (jint) new CIMClass(cls);
|
2312 schuur 1.1 }
|
2313 schuur 1.5 Catch(jEnv);
|
2314 schuur 1.1 return 0;
2315 }
|
2316 schuur 1.3
2317 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteClass
|
2318 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop) {
|
2319 schuur 1.3 CIMClient *cCc=(CIMClient*)jCc;
2320 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2321 try {
|
2322 schuur 1.5 checkNs(cop,jNs);
|
2323 schuur 1.3 cCc->deleteClass(cop->getNameSpace(),cop->getClassName());
2324 }
|
2325 schuur 1.5 Catch(jEnv);
|
2326 schuur 1.3 return;
2327 }
2328
2329 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createClass
|
2330 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, int jCl) {
|
2331 schuur 1.3 CIMClient *cCc=(CIMClient*)jCc;
2332 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2333 CIMClass *cl=(CIMClass*)jCl;
2334
2335 try {
2336 cCc->createClass(cop->getNameSpace(),*cl);
2337 }
|
2338 schuur 1.5 Catch(jEnv);
|
2339 schuur 1.3 return;
2340 }
2341
2342 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setClass
|
2343 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jCl) {
|
2344 schuur 1.1 CIMClient *cCc=(CIMClient*)jCc;
2345 CIMObjectPath *cop=(CIMObjectPath*)jCop;
|
2346 schuur 1.3 CIMClass *cl=(CIMClass*)jCl;
2347
|
2348 schuur 1.1 try {
|
2349 schuur 1.5 checkNs(cop,jNs);
|
2350 schuur 1.3 cCc->modifyClass(cop->getNameSpace(),*cl);
|
2351 schuur 1.1 }
|
2352 schuur 1.5 Catch(jEnv);
|
2353 schuur 1.3 return ;
|
2354 schuur 1.1 }
|
2355 schuur 1.3
2356 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClasses
|
2357 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, int jCop, jboolean deep, jboolean lo) {
|
2358 schuur 1.1 CIMClient *cCc=(CIMClient*)jCc;
2359 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2360 try {
|
2361 schuur 1.5 checkNs(cop,jNs);
|
2362 schuur 1.3 Array<CIMClass> enm=cCc->enumerateClasses(
|
2363 schuur 1.1 cop->getNameSpace(),cop->getClassName(),(Boolean)deep,(Boolean)lo);
|
2364 schuur 1.3 return (jint) new Array<CIMClass>(enm);
|
2365 schuur 1.1 }
|
2366 schuur 1.5 Catch(jEnv);
|
2367 schuur 1.1 return 0;
2368 }
2369
|
2370 schuur 1.3 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClassNames
|
2371 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep) {
|
2372 schuur 1.1 CIMClient *cCc=(CIMClient*)jCc;
2373 CIMObjectPath *cop=(CIMObjectPath*)jCop;
|
2374 schuur 1.3 CIMNamespaceName ns=cop->getNameSpace();
|
2375 schuur 1.1 try {
|
2376 schuur 1.5 checkNs(cop,jNs);
|
2377 schuur 1.3 Array<CIMName> enm=cCc->enumerateClassNames(
2378 ns,cop->getClassName(),(Boolean)deep);
2379 Array<CIMObjectPath> *enmop=new Array<CIMObjectPath>();
2380 for (int i=0,m=enm.size(); i<m; i++) {
2381 enmop->append(CIMObjectPath(String::EMPTY,ns,enm[i]));
2382 }
2383 return (jint)enmop;
2384 }
|
2385 schuur 1.5 Catch(jEnv);
|
2386 schuur 1.3 return 0;
2387 }
2388
2389
2390
2391 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getInstance
|
2392 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, int jNs, int jCop, jboolean lo) {
|
2393 schuur 1.3 CIMClient *cCc=(CIMClient*)jCc;
2394 CIMObjectPath *cop=(CIMObjectPath*)jCop;
|
2395 schuur 1.5
|
2396 schuur 1.3 try {
|
2397 schuur 1.5 checkNs(cop,jNs);
|
2398 schuur 1.3 CIMInstance inst=cCc->getInstance(cop->getNameSpace(),*cop,(Boolean)lo);
2399 return (jint) new CIMInstance(inst);
|
2400 schuur 1.1 }
|
2401 schuur 1.5 Catch(jEnv);
|
2402 schuur 1.1 return 0;
2403 }
2404
|
2405 schuur 1.3 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteInstance
|
2406 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop) {
|
2407 schuur 1.3 CIMClient *cCc=(CIMClient*)jCc;
2408 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2409 try {
|
2410 schuur 1.5 checkNs(cop,jNs);
|
2411 schuur 1.3 cCc->deleteInstance(cop->getNameSpace(),*cop);
2412 }
|
2413 schuur 1.5 Catch(jEnv);
|
2414 schuur 1.3 return;
2415 }
2416
|
2417 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1createInstance
|
2418 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, int jCi) {
|
2419 schuur 1.1 CIMClient *cCc=(CIMClient*)jCc;
2420 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2421 CIMInstance *ci=(CIMInstance*)jCi;
|
2422 schuur 1.3
|
2423 schuur 1.1 try {
|
2424 schuur 1.5 checkNs(cop,jNs);
|
2425 schuur 1.1 CIMObjectPath obj=cCc->createInstance(cop->getNameSpace(),*ci);
|
2426 schuur 1.3 return (jint) new CIMObjectPath(obj);
|
2427 schuur 1.1 }
|
2428 schuur 1.5 Catch(jEnv);
2429 return 0;
|
2430 schuur 1.1 }
|
2431 schuur 1.3
|
2432 schuur 1.1 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setInstance
|
2433 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jCi) {
|
2434 schuur 1.1 CIMClient *cCc=(CIMClient*)jCc;
2435 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2436 CIMInstance *ci=(CIMInstance*)jCi;
|
2437 schuur 1.3
|
2438 schuur 1.1 try {
|
2439 schuur 1.5 checkNs(cop,jNs);
|
2440 schuur 1.1 cCc->modifyInstance(cop->getNameSpace(),*ci);
2441 }
|
2442 schuur 1.5 Catch(jEnv);
|
2443 schuur 1.1 return ;
|
2444 schuur 1.3 }
2445
2446 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstances
|
2447 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep, jboolean lo) {
|
2448 schuur 1.3 CIMClient *cCc=(CIMClient*)jCc;
2449 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2450 try {
|
2451 schuur 1.5 checkNs(cop,jNs);
|
2452 schuur 1.3 Array<CIMInstance> enm=cCc->enumerateInstances(
2453 cop->getNameSpace(),cop->getClassName(),(Boolean)deep,(Boolean)lo);
2454 return (jint) new Array<CIMInstance>(enm);
2455 }
|
2456 schuur 1.5 Catch(jEnv);
|
2457 schuur 1.3 return 0;
2458 }
2459
2460 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstanceNames
|
2461 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep) {
|
2462 schuur 1.3 CIMClient *cCc=(CIMClient*)jCc;
2463 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2464 try {
|
2465 schuur 1.5 checkNs(cop,jNs);
|
2466 schuur 1.3 Array<CIMObjectPath> enm=cCc->enumerateInstanceNames(
2467 cop->getNameSpace(),cop->getClassName()); //,(Boolean)deep);
2468 return (jint) new Array<CIMObjectPath>(enm);
2469 }
|
2470 schuur 1.5 Catch(jEnv);
2471 return 0;
2472 }
2473
2474
2475 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getQualifier
2476 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop) {
2477 CIMClient *cCc=(CIMClient*)jCc;
2478 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2479 try {
2480 checkNs(cop,jNs);
2481 CIMQualifierDecl *val=new CIMQualifierDecl(cCc->getQualifier(cop->getNameSpace(),cop->getClassName()));
2482 return (jint)val;
|
2483 schuur 1.3 }
|
2484 schuur 1.5 Catch(jEnv);
|
2485 schuur 1.3 return 0;
2486 }
2487
|
2488 schuur 1.5 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteQualifier
2489 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop) {
2490 CIMClient *cCc=(CIMClient*)jCc;
2491 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2492 try {
2493 checkNs(cop,jNs);
2494 cCc->deleteQualifier(cop->getNameSpace(),cop->getClassName());
2495 }
2496 Catch(jEnv);
2497 return;
2498 }
2499
2500 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setQualifier
2501 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jQ) {
2502 CIMClient *cCc=(CIMClient*)jCc;
2503 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2504 CIMQualifierDecl *qt=(CIMQualifierDecl*)jQ;
2505 try {
2506 checkNs(cop,jNs);
2507 cCc->setQualifier(cop->getNameSpace(),*qt);
2508 }
2509 schuur 1.5 Catch(jEnv);
2510 return;
2511 }
2512
|
2513 schuur 1.1
2514 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty
|
2515 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn) {
|
2516 schuur 1.3 CIMClient *cCc=(CIMClient*)jCc;
2517 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2518 const char *str=jEnv->GetStringUTFChars(jPn,NULL);
2519 CIMName pName(str);
2520 jEnv->ReleaseStringUTFChars(jPn,str);
2521 try {
|
2522 schuur 1.5 checkNs(cop,jNs);
|
2523 schuur 1.3 CIMValue *val=new CIMValue(cCc->getProperty(cop->getNameSpace(),*cop,pName));
2524 return (jint)val;
2525 }
|
2526 schuur 1.5 Catch(jEnv);
|
2527 schuur 1.3 return 0;
2528 }
|
2529 schuur 1.5
|
2530 schuur 1.1 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty
|
2531 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn, jint jV) {
|
2532 schuur 1.3 CIMClient *cCc=(CIMClient*)jCc;
2533 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2534 CIMValue *val=(CIMValue*)jCop;
2535 const char *str=jEnv->GetStringUTFChars(jPn,NULL);
2536 CIMName pName(str);
2537 jEnv->ReleaseStringUTFChars(jPn,str);
2538 try {
|
2539 schuur 1.5 checkNs(cop,jNs);
|
2540 schuur 1.3 cCc->setProperty(cop->getNameSpace(),*cop,pName,*val);
2541 }
|
2542 schuur 1.5 Catch(jEnv);
|
2543 schuur 1.3 return;
2544 }
2545
2546 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod
|
2547 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn, jobject jIn, jobject jOut) {
|
2548 schuur 1.3 CIMClient *cCc=(CIMClient*)jCc;
2549 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2550 const char *str=jEnv->GetStringUTFChars(jMn,NULL);
2551 CIMName method(str);
2552 jEnv->ReleaseStringUTFChars(jMn,str);
2553
2554 Array<CIMParamValue> in;
2555 Array<CIMParamValue> out;
2556
2557 for (int i=0,m=jEnv->CallIntMethod(jIn,JMPIjvm::jv.VectorSize); i<m; i++) {
2558 JMPIjvm::checkException(jEnv);
2559 jobject jProp=jEnv->CallObjectMethod(jIn,JMPIjvm::jv.VectorElementAt,i);
2560 JMPIjvm::checkException(jEnv);
2561 CIMProperty *p=((CIMProperty*)jEnv->CallIntMethod(jProp,JMPIjvm::jv.PropertyCInst));
2562 JMPIjvm::checkException(jEnv);
2563 in.append(CIMParamValue(p->getName().getString(),p->getValue()));
2564 }
2565 try {
|
2566 schuur 1.5 checkNs(cop,jNs);
|
2567 schuur 1.3 CIMValue *val=new CIMValue(cCc->invokeMethod(cop->getNameSpace(),*cop,method,in,out));
2568 return (jint)val;
2569
2570 for (int i=0,m=out.size(); i<m; i++) {
2571 const CIMParamValue & parm=out[i];
2572 const CIMValue v=parm.getValue();
2573 CIMProperty *p=new CIMProperty(parm.getParameterName(),v,v.getArraySize());
2574 jobject prop=jEnv->NewObject(JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,(jint)p);
2575 jEnv->CallVoidMethod(jOut,JMPIjvm::jv.VectorAddElement,prop);
2576 }
2577 }
|
2578 schuur 1.5 Catch(jEnv);
|
2579 schuur 1.3 return 0;
2580 }
2581
2582
|
2583 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery
|
2584 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jQuery, jstring jQl) {
|
2585 schuur 1.3 CIMClient *cCc=(CIMClient*)jCc;
2586 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2587
2588 const char *str=jEnv->GetStringUTFChars(jQuery,NULL);
2589 String query(str);
2590 jEnv->ReleaseStringUTFChars(jQuery,str);
2591 str=jEnv->GetStringUTFChars(jQl,NULL);
2592 String ql(str);
2593 jEnv->ReleaseStringUTFChars(jQl,str);
2594
2595 try {
|
2596 schuur 1.5 checkNs(cop,jNs);
|
2597 schuur 1.3 Array<CIMObject> enm=cCc->execQuery(
2598 cop->getNameSpace(),query,ql);
2599 Array<CIMInstance> *enmInst=new Array<CIMInstance>();
2600 for (int i=0,m=enm.size(); i<m; i++) {
2601 enmInst->append(CIMInstance(enm[i]));
2602 }
2603 return (jint)enmInst;
2604 }
|
2605 schuur 1.5 Catch(jEnv);
|
2606 schuur 1.3 return 0;
2607 }
2608
|
2609 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associatorNames
|
2610 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,
|
2611 schuur 1.3 jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole) {
2612 CIMClient *cCc=(CIMClient*)jCc;
2613 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2614
2615 const char *str=jEnv->GetStringUTFChars(jAssocClass,NULL);
2616 CIMName assocClass(str);
2617 jEnv->ReleaseStringUTFChars(jAssocClass,str);
2618 str=jEnv->GetStringUTFChars(jResultClass,NULL);
2619 CIMName resultClass(str);
2620 jEnv->ReleaseStringUTFChars(jResultClass,str);
2621 str=jEnv->GetStringUTFChars(jRole,NULL);
2622 String role(str);
2623 jEnv->ReleaseStringUTFChars(jRole,str);
2624 str=jEnv->GetStringUTFChars(jResultRole,NULL);
2625 String resultRole(str);
2626 jEnv->ReleaseStringUTFChars(jResultRole,str);
2627
2628 try {
|
2629 schuur 1.5 checkNs(cop,jNs);
|
2630 schuur 1.3 Array<CIMObjectPath> enm=cCc->associatorNames(
2631 cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole);
2632 return (jint) new Array<CIMObjectPath>(enm);
2633 }
|
2634 schuur 1.5 Catch(jEnv);
|
2635 schuur 1.3 return 0;
2636 }
2637
|
2638 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associators
|
2639 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,
|
2640 schuur 1.3 jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole,
|
2641 schuur 1.1 jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray propertyList) {
|
2642 schuur 1.3 CIMClient *cCc=(CIMClient*)jCc;
2643 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2644
2645 const char *str=jEnv->GetStringUTFChars(jAssocClass,NULL);
2646 CIMName assocClass(str);
2647 jEnv->ReleaseStringUTFChars(jAssocClass,str);
2648 str=jEnv->GetStringUTFChars(jResultClass,NULL);
2649 CIMName resultClass(str);
2650 jEnv->ReleaseStringUTFChars(jResultClass,str);
2651 str=jEnv->GetStringUTFChars(jRole,NULL);
2652 String role(str);
2653 jEnv->ReleaseStringUTFChars(jRole,str);
2654 str=jEnv->GetStringUTFChars(jResultRole,NULL);
2655 String resultRole(str);
2656 jEnv->ReleaseStringUTFChars(jResultRole,str);
2657
2658 try {
|
2659 schuur 1.5 checkNs(cop,jNs);
|
2660 schuur 1.3 Array<CIMObject> enm=cCc->associators(
2661 cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole,
2662 (Boolean)includeQualifiers,(Boolean)includeClassOrigin,CIMPropertyList());
2663 Array<CIMInstance> *enmInst=new Array<CIMInstance>();
2664 for (int i=0,m=enm.size(); i<m; i++) {
2665 enmInst->append(CIMInstance(enm[i]));
2666 }
2667 return (jint)enmInst;
2668 }
|
2669 schuur 1.5 Catch(jEnv);
|
2670 schuur 1.3 return 0;
2671 }
2672
|
2673 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1referenceNames
|
2674 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,
|
2675 schuur 1.3 jstring jAssocClass, jstring jRole) {
2676 CIMClient *cCc=(CIMClient*)jCc;
2677 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2678
2679 const char *str=jEnv->GetStringUTFChars(jAssocClass,NULL);
2680 CIMName assocClass(str);
2681 jEnv->ReleaseStringUTFChars(jAssocClass,str);
2682 str=jEnv->GetStringUTFChars(jRole,NULL);
2683 String role(str);
2684 jEnv->ReleaseStringUTFChars(jRole,str);
2685
2686 try {
|
2687 schuur 1.5 checkNs(cop,jNs);
|
2688 schuur 1.3 Array<CIMObjectPath> enm=cCc->referenceNames(
2689 cop->getNameSpace(),*cop,assocClass,role);
2690 return (jint) new Array<CIMObjectPath>(enm);
2691 }
|
2692 schuur 1.5 Catch(jEnv);
|
2693 schuur 1.3 return 0;
2694 }
2695
|
2696 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1references
|
2697 schuur 1.5 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,
|
2698 schuur 1.3 jstring jAssocClass, jstring jRole,
|
2699 schuur 1.1 jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray propertyList) {
|
2700 schuur 1.3 CIMClient *cCc=(CIMClient*)jCc;
2701 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2702
2703 const char *str=jEnv->GetStringUTFChars(jAssocClass,NULL);
2704 CIMName assocClass(str);
2705 jEnv->ReleaseStringUTFChars(jAssocClass,str);
2706 str=jEnv->GetStringUTFChars(jRole,NULL);
2707 String role(str);
2708 jEnv->ReleaseStringUTFChars(jRole,str);
2709
2710 try {
|
2711 schuur 1.5 checkNs(cop,jNs);
|
2712 schuur 1.3 Array<CIMObject> enm=cCc->references(
2713 cop->getNameSpace(),*cop,assocClass,role,
2714 (Boolean)includeQualifiers,(Boolean)includeClassOrigin,CIMPropertyList());
2715 Array<CIMInstance> *enmInst=new Array<CIMInstance>();
2716 for (int i=0,m=enm.size(); i<m; i++) {
2717 enmInst->append(CIMInstance(enm[i]));
2718 }
2719 return (jint)enmInst;
2720 }
|
2721 schuur 1.5 Catch(jEnv);
2722 return 0;
2723 }
2724
2725 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createNameSpace
2726 (JNIEnv *jEnv, jobject jThs, jint jCc, jstring jNs) {
2727 CIMClient *cCc=(CIMClient*)jCc;
2728
2729 const char* str=jEnv->GetStringUTFChars(jNs,NULL);
2730 String ns(str);
2731 jEnv->ReleaseStringUTFChars(jNs,str);
2732
2733 CIMInstance newInstance(CIMName("__Namespace"));
2734 newInstance.addProperty(CIMProperty(CIMName ("name"),ns));
2735
2736 try {
2737 // checkNs(cop,jNs);
2738 cCc->createInstance(CIMNamespaceName("root"),newInstance);
|
2739 schuur 1.3 }
|
2740 schuur 1.5 Catch(jEnv);
2741 return;
2742 }
2743
2744 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateNameSpaces
2745 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jboolean deep, jobject jVec) {
2746 return jVec;
2747 }
2748
2749 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteNameSpace
2750 (JNIEnv *jEnv, jobject jThs, jint jCc, jstring jNs) {
2751 CIMClient *cCc=(CIMClient*)jCc;
|
2752 schuur 1.3 }
|
2753 schuur 1.1
|
2754 schuur 1.5 } // extern "C"
|
2755 schuur 1.1
2756 PEGASUS_NAMESPACE_END
2757
2758
2759
2760
2761
2762
2763
|
Return to
JMPIImpl.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI