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
51 PEGASUS_USING_STD;
52 PEGASUS_NAMESPACE_BEGIN
53
54 JavaVM *JMPIjvm::jvm=NULL;
55 JvmVector JMPIjvm::jv;
56
57 typedef struct {
58 int clsIndex;
59 const char * methodName;
60 const char * signature;
61 } METHOD_STRUCT;
62
63 const char* classNames[]={
64 schuur 1.1 "java/util/Vector" , // 0
65 "java/lang/Boolean", // 1
66 "java/lang/Byte", // 2
67 "java/lang/Short", // 3
68 "java/lang/Integer", // 4
69 "java/lang/Long", // 5
70 "java/lang/Float", // 6
71 "java/lang/Double", // 7
72 "org/pegasus/jmpi/UnsignedInt8", // 8
73 "org/pegasus/jmpi/UnsignedInt16", // 9
74 "org/pegasus/jmpi/UnsignedInt32", // 10
75 "org/pegasus/jmpi/UnsignedInt64", // 11
76 "org/pegasus/jmpi/CIMObjectPath", // 12
77 "org/pegasus/jmpi/CIMException", // 13
78 "java/math/BigInteger", // 14
79 "org/pegasus/jmpi/CIMProperty", // 15
80
81 "org/pegasus/jmpi/CIMOMHandle", // 16
82 "org/pegasus/jmpi/CIMClass", // 17
83 "org/pegasus/jmpi/CIMInstance", // 18
84 "org/pegasus/jmpi/CIMValue", // 19
85 schuur 1.1 "java/lang/Object", // 20
86 "java/lang/Throwable", // 21
87 "java/lang/String", // 22
88 "org/pegasus/jmpi/JarClassLoader", // 23
89 "org/pegasus/jmpi/CIMDateTime", // 24
90 };
91
92
93 const METHOD_STRUCT instanceMethodNames[]={
94 /*00*/ { 0, "<init>", "()V" },
95 /*01*/ { 1, "<init>", "(Z)V" },
96 /*02*/ { 2, "<init>", "(B)V" },
97 /*03*/ { 3, "<init>", "(S)V" },
98 /*04*/ { 4, "<init>", "(I)V" },
99 /*05*/ { 5, "<init>", "(J)V" }, // ???
100 /*06*/ { 6, "<init>", "(F)V" },
101 /*07*/ { 7, "<init>", "(D)V" },
102 /*08*/ { 8, "<init>", "(S)V" },
103 /*09*/ { 9, "<init>", "(I)V" },
104 /*10*/ { 10,"<init>", "(J)V" },
105 /*11*/ { 11,"<init>", "(Ljava/math/BigInteger;)V" },
106 schuur 1.1 /*12*/ { 12,"<init>", "(I)V" },
107 /*13*/ { 13,"<init>", "(Ljava/lang/String;)V" },
108 /*14*/ { 15,"<init>", "(I)V" },
109 /*15*/ { 0, "addElement", "(Ljava/lang/Object;)V" },
110
111 /*16*/ { 0, "elementAt", "(I)Ljava/lang/Object;" },
112 /*17*/ { 16,"<init>", "(I)V" },
113 /*18*/ { 13,"<init>", "(I)V" },
114 /*19*/ { 17,"<init>", "(I)V" },
115 /*20*/ { 18,"<init>", "(I)V" },
116 /*21*/ { 12,"<init>", "(I)V" },
117 /*22*/ { 12,"cInst", "()I" },
118 /*23*/ { 18,"cInst", "()I" },
119 /*24*/ { 17,"cInst", "()I" },
120 /*25*/ { 20,"toString", "()Ljava/lang/String;" },
121 /*26*/ { 21,"getMessage", "()Ljava/lang/String;" },
122 /*27*/ { 13,"getID", "()Ljava/lang/String;" },
123 /*28*/ { 0, "size", "()I" },
124 /*29*/ { 15,"cInst", "()I" },
125 /*30*/ { 16,"getClass", "(Lorg/pegasus/jmpi/CIMObjectPath;Z)Lorg/pegasus/jmpi/CIMClass;" },
126 /*31*/ { 0, "removeElementAt", "(I)V" },
127 schuur 1.1 /*32*/ { 19,"cInst", "()I" },
128 /*33*/ { 13,"<init>", "(ILjava/lang/String;)V" },
129 /*34*/ { 13,"getCode", "()I" },
130 /*35*/ { 12,"<init>", "(I)V" },
131 };
132
133 const METHOD_STRUCT staticMethodNames[]={
134 { 14, "valueOf", "(J)Ljava/math/BigInteger;" },
135 { 23, "load", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Class;" },
136 };
137
138
139 static int methodInitDone=0;
140
141 jclass classRefs[sizeof(classNames)/sizeof(char*)];
142 jmethodID instanceMethodIDs[sizeof(instanceMethodNames)/sizeof(METHOD_STRUCT)];
143 jmethodID staticMethodIDs[sizeof(staticMethodNames)/sizeof(METHOD_STRUCT)];
144 static jclass providerClassRef;
145
146 jclass JMPIjvm::getGlobalClassRef(JNIEnv *env, const char* name) {
147 jclass localRefCls=env->FindClass(name);
148 schuur 1.1 // if (env->ExceptionOccurred())
149 // env->ExceptionDescribe();
150 if (localRefCls==NULL) return JNI_FALSE;
151 jclass globalRefCls=(jclass) env->NewGlobalRef(localRefCls);
152 env->DeleteLocalRef(localRefCls);
153 return globalRefCls;
154 }
155
156 JMPIjvm::JMPIjvm() {
157 initJVM();
158 }
159
160 JMPIjvm::~JMPIjvm() {
161
162 }
163
164 int JMPIjvm::cacheIDs(JNIEnv *env) {
165 if (methodInitDone==1) return JNI_TRUE;
166 if (methodInitDone==-1) return JNI_FALSE;
167
168 methodInitDone=-1;
169 schuur 1.1 for (unsigned i=0; i<(sizeof(classNames)/sizeof(char*)); i++) {
170 // cerr<<"--- Trying "<< classNames[i]<<endl;
171 if ((classRefs[i]=getGlobalClassRef(env,classNames[i]))==NULL) return JNI_FALSE;
172 }
173
174 for (unsigned j=0; j<(sizeof(instanceMethodNames)/sizeof(METHOD_STRUCT)); j++) {
175 // cerr<<"--- Trying "<<j<<": "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<endl;
176 if ((instanceMethodIDs[j]=env->GetMethodID(
177 classRefs[instanceMethodNames[j].clsIndex],
178 instanceMethodNames[j].methodName,instanceMethodNames[j].signature))==NULL) return 0;
179 if ((instanceMethodIDs[j]=env->GetMethodID(classRefs[instanceMethodNames[j].clsIndex],instanceMethodNames[j].methodName,instanceMethodNames[j].signature))==NULL)
180 return 0;
181 }
182
183 for (unsigned k=0; k<(sizeof(staticMethodNames)/sizeof(METHOD_STRUCT)); k++) {
184 // cerr<<"--- Trying "<<k<<endl;
185 if ((staticMethodIDs[k]=env->GetStaticMethodID(
186 classRefs[staticMethodNames[k].clsIndex],
187 staticMethodNames[k].methodName,staticMethodNames[k].signature))==NULL) return 0;
188 }
189 // cerr<<"--- cacheIDs() done"<<endl;
190 schuur 1.1 methodInitDone=1;
191 return JNI_TRUE;
192 }
193
194 static void throwCIMException(JNIEnv *env,char *e) {
195 env->ThrowNew(classRefs[13],e);
196 }
197
198 int JMPIjvm::initJVM()
199 {
200 JavaVMInitArgs vm_args;
201 JavaVMOption options[1];
202 jint res;
203 char *envcp;
204 char classpath[1024]="-Djava.class.path=";
205 JNIEnv *env;
206
207 std::cerr<<"--- JPIjvm::initJVM()\n";
208 jv.initRc=0;
209
210 envcp=getenv("CLASSPATH");
211 schuur 1.1 if (envcp==NULL) {
212 jv.initRc=1;
213 std::cerr<<"--- jmpiJvm::initJVM(): No PEGASUS_PROVIDER_CLASSPATH environment variable found\n";
214 return -1;
215 }
216
217 strcat(classpath,envcp);
218 options[0].optionString=classpath;
219 vm_args.version=0x00010002;
220 vm_args.options=options;
221 vm_args.nOptions=1;
222 vm_args.ignoreUnrecognized=JNI_TRUE;
223
224 res=JNI_CreateJavaVM(&jvm,(void**)&env,&vm_args);
225 if (res!=0) {
226 fprintf(stderr,"Can not create Java VM\n");
227 exit(1);
228 }
229 jv.jvm=jvm;
230 jv.env=env;
231
232 schuur 1.1 if (cacheIDs(env)==1) {
233 jv.classRefs=classRefs;
234 jv.instMethodIDs=instanceMethodIDs;
235 // jv.classMethodIDs=classMethodIDs;
236 }
237
238 if (env->ExceptionOccurred()) {
239 env->ExceptionDescribe();
240 exit(1);
241 }
242
243 // dlopen("libjmpiVM.so",RTLD_NOW);
244 // std::cerr<<"--- JPIjvm::initJVM(): selfloading done\n";
245
246 return res;
247 }
248
249 JNIEnv* JMPIjvm::attachThread(JvmVector **jvp) {
250 JNIEnv* env;
251 if (jvm==NULL) initJVM();
252 jvm->AttachCurrentThread((void**)&env,NULL);
253 schuur 1.1 *jvp=&jv;
254 return env;
255 }
256
257 void JMPIjvm::detachThread() {
258 jvm->DetachCurrentThread();
259 }
260
261 jobject JMPIjvm::getProvider(JNIEnv *env, String jar, String cln,
262 const char *cn, jclass *cls)
263 {
264 static jobject gProv=NULL;
265 static jclass scls=NULL;
266 if (gProv) {
267 *cls=scls;
268 return gProv;
269 }
270
271 /*
272 std::cout<<"--- jar: "<<jar<<std::endl;
273 std::cout<<"--- cln: "<<cln<<std::endl;
274 schuur 1.1
275 jstring jjar=env->NewStringUTF((const char*)jar.getCString());
276 jstring jcln=env->NewStringUTF((const char*)cln.getCString());
277
278 jclass jcls=(jclass)env->CallStaticObjectMethod(classRefs[23],staticMethodIDs[1],
279 jjar,jcln);
280 if (env->ExceptionCheck()) {
281 env->ExceptionDescribe();
282 std::cerr<<"--- Unable to instantiate provider "<<cn<<std::endl;
283 // return NULL;
284 }
285 */
286
287 scls=getGlobalClassRef(env,(const char*)cln.getCString());
288 if (env->ExceptionCheck()) {
289 std::cerr<<"--- Provider "<<cn<<" not found"<<std::endl;
290 return NULL;
291 }
292 *cls=scls;
293
294 jmethodID id=env->GetMethodID(*cls,"<init>","()V");
295 schuur 1.1 jobject lProv=env->NewObject(*cls,id);
296 gProv=(jobject)env->NewGlobalRef(lProv);
297 if (env->ExceptionCheck()) {
298 std::cerr<<"--- Unable to instantiate provider "<<cn<<std::endl;
299 return NULL;
300 }
301 return gProv;
302 }
303
304 jobject JMPIjvm::getProvider(JNIEnv *env, const char *cn, jclass *cls)
305 {
306 static jobject gProv=NULL;
307 static jclass scls=NULL;
308 if (gProv) {
309 *cls=scls;
310 return gProv;
311 }
312
313 scls=getGlobalClassRef(env,cn);
314 if (env->ExceptionCheck()) {
315 std::cerr<<"--- Provider "<<cn<<" not found"<<std::endl;
316 schuur 1.1 return NULL;
317 }
318 *cls=scls;
319
320 jmethodID id=env->GetMethodID(*cls,"<init>","()V");
321 jobject lProv=env->NewObject(*cls,id);
322 gProv=(jobject)env->NewGlobalRef(lProv);
323 if (env->ExceptionCheck()) {
324 std::cerr<<"--- Unable to instantiate provider "<<cn<<std::endl;
325 return NULL;
326 }
327 return gProv;
328 }
329
330 void JMPIjvm::checkException(JNIEnv *env)
331 {
332 jstring msg=NULL,id=NULL;
333 int code;
334 const char *cp;
335 char hcp[512]="",hcp1[128];
336 String m=String::EMPTY;
337 schuur 1.1
338 if (env->ExceptionCheck()) {
339 jthrowable err=env->ExceptionOccurred();
340 // env->ExceptionDescribe();
341 env->ExceptionClear();
342 if (err) {
343 msg=(jstring)env->CallObjectMethod(err,JMPIjvm::jv.ThrowableGetMessage);
344 code=(int)env->CallObjectMethod(err,JMPIjvm::jv.CIMExceptionGetCode);
345 id=(jstring)env->CallObjectMethod(err,JMPIjvm::jv.CIMExceptionGetID);
346 if (id) {
347 const char *cp=env->GetStringUTFChars(id,NULL);
348 strncpy(hcp1,cp,511);
349 env->ReleaseStringUTFChars(id,cp);
350 }
351
352 if (msg) {
353 const char *cp=env->GetStringUTFChars(msg,NULL);
354 strncpy(hcp,cp,511);
355 env->ReleaseStringUTFChars(msg,cp);
356 m=String(hcp);
357 }
358 schuur 1.1 // std::cerr<<"--- exception: "<<hcp1<<" ("<<hcp<<") "<<std::endl;
359 throw CIMException((CIMStatusCode)code,m);
360 }
361 }
362 }
363
364 /**************************************************************************
365 * name - NewPlatformString
366 * description - Returns a new Java string object for the specified
367 * platform string.
368 * parameters - env
369 * s Platform encoded string
370 * returns - Java string object pointer or null (0)
371 **************************************************************************/
372 jstring JMPIjvm::NewPlatformString(JNIEnv *env, char *s)
373 {
374 size_t len = strlen(s);
375 jclass cls;
376 jmethodID mid;
377 jbyteArray ary;
378
379 schuur 1.1 NULL_CHECK0(cls = (*env).FindClass("java/lang/String"));
380 NULL_CHECK0(mid = (*env).GetMethodID(cls, "<init>", "([B)V"));
381 ary = (*env).NewByteArray((jsize)len);
382 if (ary != 0) {
383 jstring str = 0;
384 (*env).SetByteArrayRegion(ary, 0, (jsize)len,
385 (jbyte *)s);
386 if (!(*env).ExceptionOccurred()) {
387 str = (jstring)(*env).NewObject(cls, mid, ary);
388 }
389 (*env).DeleteLocalRef(ary);
390 return str;
391 }
392 return 0;
393 }
394
395
396 /**************************************************************************
397 * name - NewPlatformStringArray
398 * description - Returns a new array of Java string objects for the specified
399 * array of platform strings.
400 schuur 1.1 * parameters - env
401 * strv Platform encoded string array
402 * strc Number of strings in strv
403 * returns - Java string array object pointer
404 **************************************************************************/
405 jobjectArray JMPIjvm::NewPlatformStringArray(JNIEnv *env, char **strv, int strc)
406 {
407 jarray cls;
408 jarray ary;
409 int i;
410
411 NULL_CHECK0(cls = (jarray)(*env).FindClass("java/lang/String"));
412 NULL_CHECK0(ary = (*env).NewObjectArray(strc, (jclass)cls, 0));
413 for (i = 0; i < strc; i++) {
414 jstring str = NewPlatformString(env, *strv++);
415 NULL_CHECK0(str);
416 (*env).SetObjectArrayElement((jobjectArray)ary, i, str);
417 (*env).DeleteLocalRef(str);
418 }
419 return (jobjectArray)ary;
420 }
421 schuur 1.1
422
423
424
425
426 extern "C" {
427
428
429 void throwCimException(JNIEnv *jEnv, CIMException & e) {
430 JMPIjvm::cacheIDs(jEnv);
431 jobject ev=jEnv->NewObject(classRefs[13],instanceMethodIDs[18],(jint)e.getCode());
432 jEnv->Throw((jthrowable)ev);
433 }
434
435 void throwFailedException(JNIEnv *jEnv) {
436 JMPIjvm::cacheIDs(jEnv);
437 jobject ev=jEnv->NewObject(classRefs[13],instanceMethodIDs[18],1);
438 jEnv->Throw((jthrowable)ev);
439 }
440
441 void throwNotSupportedException(JNIEnv *jEnv) {
442 schuur 1.1 JMPIjvm::cacheIDs(jEnv);
443 jobject ev=jEnv->NewObject(classRefs[13],instanceMethodIDs[18],7);
444 jEnv->Throw((jthrowable)ev);
445 }
446
447
448 // -------------------------------------
449 // ---
450 // - CIMOMHandle
451 // ---
452 // -------------------------------------
453
454 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getClass
455 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean lo) {
456 CIMOMHandle *ch=(CIMOMHandle*)jCh;
457 CIMObjectPath *cop=(CIMObjectPath*)jCop;
458 OperationContext ctx;
459 try {
460 CIMClass cc=ch->getClass(ctx,cop->getNameSpace(),cop->getClassName(),
461 (Boolean)lo,
462 true,true,CIMPropertyList());
463 schuur 1.1 return (jint)new CIMClass(cc);
464 }
465 Catch(jEnv);
466 return 0;
467 }
468
469 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumClass
470 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean lo, jobject jVec) {
471 CIMOMHandle *ch=(CIMOMHandle*)jCh;
472 CIMObjectPath *cop=(CIMObjectPath*)jCop;
473 OperationContext ctx;
474 try {
475 Array<CIMClass> en=ch->enumerateClasses(ctx,cop->getNameSpace(),cop->getClassName(),
476 true,(Boolean)lo,true,true);
477 if (!cop->getClassName().isNull())
478 en.append(ch->getClass(ctx,cop->getNameSpace(),cop->getClassName(),(Boolean)lo,
479 true,true,CIMPropertyList()));
480 for (int i=0,m=en.size(); i<m; i++) {
481 CIMClass *cls=new CIMClass(en[i]);
482 jobject jCls=jEnv->NewObject(classRefs[17],instanceMethodIDs[19],(jint)cls);
483 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],jCls);
484 schuur 1.1 }
485 return;
486 }
487 Catch(jEnv);
488 return;
489 }
490
491 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getProperty
492 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jN) {
493
494 CIMOMHandle *ch=(CIMOMHandle*)jCh;
495 CIMObjectPath *cop=(CIMObjectPath*)jCop;
496 OperationContext ctx;
497 const char *str=jEnv->GetStringUTFChars(jN,NULL);
498
499 try {
500 CIMName prop(str);
501 CIMValue *cv = new CIMValue(ch->getProperty(ctx, cop->getNameSpace(),*cop,prop));
502 jEnv->ReleaseStringUTFChars(jN,str);
503 return (jint)(void*)cv;
504 }
505 schuur 1.1 Catch(jEnv);
506 return -1;
507 }
508
509 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance
510 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop) {
511
512 CIMOMHandle *ch=(CIMOMHandle*)jCh;
513 CIMObjectPath *cop=(CIMObjectPath*)jCop;
514 OperationContext ctx;
515
516 try {
517 ch->deleteInstance(ctx,cop->getNameSpace(),*cop);
518 }
519 Catch(jEnv);
520 }
521
522 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumInstances
523 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean jDeep, jboolean jLocalOnly, jobject jVec) {
524
525 CIMOMHandle *ch=(CIMOMHandle*)jCh;
526 schuur 1.1 CIMObjectPath *cop=(CIMObjectPath*)jCop;
527 OperationContext ctx;
528
529 try {
530 Array<CIMInstance> inst=ch->enumerateInstances(ctx,cop->getNameSpace(),cop->getClassName(),
531 (Boolean)jDeep,(Boolean)jLocalOnly,true,true,CIMPropertyList());
532 for (int i=0,s=inst.size(); i<s; i++){
533 CIMInstance *ci=new CIMInstance(inst[i]);
534 jobject jCi=jEnv->NewObject(classRefs[18],instanceMethodIDs[20],(jint)ci);
535 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],jCi);
536 }
537 }
538 Catch(jEnv);
539 }
540
541 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getInstance
542 (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean jLocalOnly) {
543
544 CIMOMHandle *ch=(CIMOMHandle*)jCh;
545 CIMObjectPath *cop=(CIMObjectPath*)jCop;
546 OperationContext ctx;
547 schuur 1.1
548 try {
549 CIMInstance *inst=new CIMInstance(ch->getInstance(ctx,cop->getNameSpace(),*cop,
550 (Boolean)jLocalOnly,false,false,CIMPropertyList()));
551 return (jint)(void*)inst;
552 }
553 Catch(jEnv);
554 return -1;
555 }
556
557
558
559 // -------------------------------------
560 // ---
561 // - CIMClass
562 // ---
563 // -------------------------------------
564
565 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1newInstance
566 (JNIEnv *jEnv, jobject jThs, jint jCls) {
567 CIMClass *cls=(CIMClass*)jCls;
568 schuur 1.1 // Array<Sint8> ar;
569 // cls->toXml(ar);
570 // cout<<"--- class: "<<ar.getData()<<endl;
571
572 try {
573 CIMInstance *ci=new CIMInstance(cls->getClassName());
574 for (int i=0,m=cls->getQualifierCount(); i<m; i++)
575 ci->addQualifier(cls->getQualifier(i).clone());
576 for (int i=0,m=cls->getPropertyCount(); i<m; i++) {
577 CIMProperty cp= cls->getProperty(i);
578 ci->addProperty(cp.clone());
579 // CIMProperty(cp.getName(), cp.getValue(), cp.getArraySize(),
580 // cp.getReferenceClassName(), cp.getClassOrigin()));
581 for (int j=0, s=cp.getQualifierCount(); j<s; j++)
582 ci->getProperty(i).addQualifier(cp.getQualifier(j));
583 }
584 return (jint)ci;
585 }
586 Catch(jEnv);
587 return 0;
588 }
589 schuur 1.1
590 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getName
591 (JNIEnv *jEnv, jobject jThs, jint jCls) {
592 CIMClass *cls=(CIMClass*)jCls;
593
594 try {
595 const String &cn=cls->getClassName().getString();
596 jstring str=jEnv->NewStringUTF(cn.getCString());
597 return str;
598 }
599 Catch(jEnv);
600 return 0;
601 }
602
603 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifier
604 (JNIEnv *jEnv, jobject jThs, jint jCls, jstring jN) {
605 CIMClass *cls=(CIMClass*)jCls;
606 const char *str=jEnv->GetStringUTFChars(jN,NULL);
607 jint rv=-1;
608 Uint32 pos=cls->findQualifier(String(str));
609 if (pos!=PEG_NOT_FOUND)
610 schuur 1.1 rv=(jint)new CIMQualifier(cls->getQualifier(pos));
611 jEnv->ReleaseStringUTFChars(jN,str);
612 return rv;
613 }
614
615 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperty
616 (JNIEnv *jEnv, jobject jThs, jint jCls, jstring jN) {
617 CIMClass *cls=(CIMClass*)jCls;
618 const char *str=jEnv->GetStringUTFChars(jN,NULL);
619 jint rv=-1;
620 Uint32 pos=cls->findProperty(CIMName(str));
621 if (pos!=PEG_NOT_FOUND)
622 rv=(jint)new CIMProperty(cls->getProperty(pos));
623 jEnv->ReleaseStringUTFChars(jN,str);
624 return rv;
625 }
626
627 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1hasQualifier
628 (JNIEnv *jEnv, jobject jThs, jint jCls, jstring jQ) {
629 CIMClass *cls=(CIMClass*)jCls;
630 const char *str=jEnv->GetStringUTFChars(jQ,NULL);
631 schuur 1.1 Uint32 pos=cls->findQualifier(String(str));
632 jEnv->ReleaseStringUTFChars(jQ,str);
633 return (jboolean)(pos!=PEG_NOT_FOUND);
634 }
635
636 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties
637 (JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) {
638 CIMClass *cls=(CIMClass*)jCls;
639
640 for (int i=0,s=cls->getPropertyCount(); i<s; i++) {
641 CIMProperty *cp=new CIMProperty(cls->getProperty(i));
642 jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)cp);
643 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop);
644 }
645 return jVec;
646 }
647
648 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1new
649 (JNIEnv *jEnv, jobject jThs, jstring jN) {
650 const char *str=jEnv->GetStringUTFChars(jN,NULL);
651 CIMClass *cls = new CIMClass(CIMName(str), CIMName());
652 schuur 1.1 jEnv->ReleaseStringUTFChars(jN,str);
653 return (jint)(void*)cls;
654 }
655
656 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getSuperClass
657 (JNIEnv *jEnv, jobject jThs, jint jCls) {
658 CIMClass *cls =(CIMClass *)jCls;
659 const String &cn=cls->getSuperClassName().getString();
660 jstring str=jEnv->NewStringUTF(cn.getCString());
661 return str;
662 }
663
664 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getKeys
665 (JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec){
666 CIMClass *cls=(CIMClass*)jCls;
667 if (cls->hasKeys()) {
668 Array<CIMName> keyNames;
669 cls->getKeyNames(keyNames);
670 for(int i=0, s=keyNames.size();i<s;i++){
671 Uint32 pos=cls->findProperty(keyNames[i]);
672 if (pos!=PEG_NOT_FOUND){
673 schuur 1.1 CIMProperty *cp=new CIMProperty(cls->getProperty(pos));
674 jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)cp);
675 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop);
676 }
677 }
678 }
679 return jVec;
680 }
681
682 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethod
683 (JNIEnv *jEnv, jobject jThs, jint jCls, jstring jN) {
684 CIMClass *cls=(CIMClass*)jCls;
685 const char *str=jEnv->GetStringUTFChars(jN,NULL);
686 jint rv=-1;
687 Uint32 pos=cls->findMethod(String(str));
688 if (pos!=PEG_NOT_FOUND) {
689 rv=(jint)new CIMMethod(cls->getMethod(pos));
690 }
691 jEnv->ReleaseStringUTFChars(jN,str);
692 return rv;
693 }
694 schuur 1.1
695 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1equals
696 (JNIEnv *jEnv, jobject jThs, jint jCls, jint jClsToBeCompared) {
697 CIMClass *cls = (CIMClass*)jCls;
698 CIMClass *clsToBeCompared = (CIMClass*)jClsToBeCompared;
699 return cls->identical(*clsToBeCompared);
700 }
701
702 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1finalize
703 (JNIEnv *jEnv, jobject jThs, jint jCls) {
704 CIMClass *cls=(CIMClass*)jCls;
705 delete cls;
706 }
707
708
709
710 // -------------------------------------
711 // ---
712 // - CIMInstance
713 // ---
714
715 schuur 1.1 // -------------------------------------
716 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1new
717 (JNIEnv *jEnv, jobject jThs) {
718 return (jint)new CIMInstance();
719 }
720
721 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1newCn
722 (JNIEnv *jEnv, jobject jThs, jstring jN) {
723 const char *str=jEnv->GetStringUTFChars(jN,NULL);
724 return (jint)new CIMInstance(CIMName(str));
725 }
726
727 //Added by Andy Viciu
728 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setName
729 (JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN) {
730 CIMInstance *ci=(CIMInstance*)jInst;
731 const char *str=jEnv->GetStringUTFChars(jN,NULL);
732 /* NOT SUPPORTED AND NOT NEEDED*/
733 }
734
735 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperty
736 schuur 1.1 (JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN, jint jV) {
737 CIMInstance *ci=(CIMInstance*)jInst;
738 CIMValue *cv=(CIMValue*)jV;
739 const char *str=jEnv->GetStringUTFChars(jN,NULL);
740 Uint32 pos=ci->findProperty(CIMName(str));
741
742 if (pos!=PEG_NOT_FOUND) {
743 CIMProperty cp=ci->getProperty(pos);
744 if (cp.getType()==cv->getType())
745 cp.setValue(*cv);
746 else {
747 throw CIMException(CIM_ERR_FAILED, String("Type mismatch"));
748 cerr<<"!!! CIMInstance.setProperty - Wrong type of CIMValue (instance name:"<<ci->getClassName().getString()<<", property name: "<<str<<")";
749 }
750 }
751 else {
752 CIMProperty *cp=new CIMProperty(CIMName(str),*cv);
753 ci->addProperty(*cp);
754 //throw CIMException(CIM_ERR_FAILED, String(str).append(String(" - Property not found")));
755 }
756
757 schuur 1.1 jEnv->ReleaseStringUTFChars(jN,str);
758 }
759
760 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperty
761 (JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN) {
762 CIMInstance *ci=(CIMInstance*)jInst;
763 const char *str=jEnv->GetStringUTFChars(jN,NULL);
764 jint rv=-1;
765 try {
766 Uint32 pos=ci->findProperty(CIMName(str));
767 if (pos!=PEG_NOT_FOUND) {
768 CIMProperty *cp=new CIMProperty(ci->getProperty(pos));
769 rv=(jint)cp;
770 }
771 }
772 Catch(jEnv);
773 jEnv->ReleaseStringUTFChars(jN,str);
774 return rv;
775 }
776
777 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getKeyValuePairs
778 schuur 1.1 (JNIEnv *jEnv, jobject jThs, jint jInst, jobject jVec) {
779 CIMInstance *ci=(CIMInstance*)jInst;
780
781 for (int i=0,s=ci->getPropertyCount(); i<s; i++) {
782 if (ci->getProperty(i).findQualifier(String("key"))!=PEG_NOT_FOUND) {
783 CIMProperty *cp=new CIMProperty(ci->getProperty(i));
784 jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)cp);
785 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop);
786 }
787 }
788
789 return jVec;
790 }
791
792 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMInstance__1getClassName
793 (JNIEnv *jEnv, jobject jThs, jint jInst) {
794 CIMInstance *ci=(CIMInstance*)jInst;
795 const String &cn=ci->getClassName().getString();
796 jstring str=jEnv->NewStringUTF(cn.getCString());
797 return str;
798 }
799 schuur 1.1
800 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getQualifier
801 (JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN) {
802 CIMInstance *ci=(CIMInstance*)jInst;
803 const char *str=jEnv->GetStringUTFChars(jN,NULL);
804 jint rv=-1;
805 Uint32 pos=ci->findQualifier(String(str));
806 if (pos!=PEG_NOT_FOUND) {
807 rv=(jint)new CIMQualifier(ci->getQualifier(pos));
808 }
809 jEnv->ReleaseStringUTFChars(jN,str);
810 return rv;
811 }
812
813 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1clone
814 (JNIEnv *jEnv, jobject jThs, jint jInst) {
815 CIMInstance *ci=(CIMInstance *)jInst;
816 CIMInstance* cl=new CIMInstance(ci->clone());
817 return (jint)(void*)cl;
818 }
819
820 schuur 1.1 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperties
821 (JNIEnv *jEnv, jobject jThs, jint jInst, jobject jVec) {
822 CIMInstance *ci=(CIMInstance*)jInst;
823 for (int i=0,s=ci->getPropertyCount(); i<s; i++) {
824 CIMProperty *cp=new CIMProperty(ci->getProperty(i));
825 jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)cp);
826 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop);
827 }
828 return jVec;
829 }
830
831 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1finalize
832 (JNIEnv *jEnv, jobject jThs, jint jInst) {
833 CIMInstance *ci=(CIMInstance*)jInst;
834 delete ci;
835 }
836
837
838 // -------------------------------------
839 // ---
840 // - CIMObjectPath
841 schuur 1.1 // ---
842 // -------------------------------------
843
844 CIMObjectPath* construct() {
845 CIMObjectPath *cop=new CIMObjectPath();
846 _nameSpace n;
847 cop->setNameSpace(n.nameSpace());
848 cop->setHost(n.hostName());
849 return cop;
850 }
851
852 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1new
853 (JNIEnv *jEnv, jobject jThs) {
854 return (jint)construct();
855 }
856
857 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCn
858 (JNIEnv *jEnv, jobject jThs, jstring jCn) {
859 CIMObjectPath *cop=construct();
860 const char *str=jEnv->GetStringUTFChars(jCn,NULL);
861 if (str) cop->setClassName(str);
862 schuur 1.1 jEnv->ReleaseStringUTFChars(jCn,str);
863 return (jint)(void*)cop;
864 }
865
866 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCnNs
867 (JNIEnv *jEnv, jobject jThs, jstring jCn, jstring jNs) {
868 CIMObjectPath *cop=construct();
869
870 const char *str1=jEnv->GetStringUTFChars(jCn,NULL);
871 const char *str2=jEnv->GetStringUTFChars(jNs,NULL);
872 try {
873 if (str1) cop->setClassName(str1);
874 if (str2) cop->setNameSpace(str2);
875 }
876 catch (Exception e) {
877 jobject ev=jEnv->NewObject(classRefs[13],instanceMethodIDs[33],(jint)1,jEnv->NewStringUTF(e.getMessage().getCString()));
878 jEnv->Throw((jthrowable)ev);
879 }
880
881 jEnv->ReleaseStringUTFChars(jCn,str1);
882 jEnv->ReleaseStringUTFChars(jNs,str2);
883 schuur 1.1 return (jint)(void*)cop;
884 }
885
886 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1_newCi
887 (JNIEnv *jEnv, jobject jThs, jint jInst) {
888 CIMInstance *ci = (CIMInstance *)jInst;
889 CIMObjectPath *cop=new CIMObjectPath(ci->getPath());
890 _nameSpace n;
891 if (cop->getNameSpace().isNull()) cop->setNameSpace(n.nameSpace());
892 if (cop->getHost()==NULL) cop->setHost(n.hostName());
893 return (jint)(void*)cop;
894 }
895
896 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1finalize
897 (JNIEnv *jEnv, jobject jThs, jint jCop) {
898 CIMObjectPath *cop=(CIMObjectPath*)jCop;
899 delete cop;
900 }
901
902 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getHost
903 (JNIEnv *jEnv, jobject jThs, jint jOp) {
904 schuur 1.1 CIMObjectPath *cop=(CIMObjectPath*)jOp;
905 const String &hn=cop->getHost();
906 jstring str=jEnv->NewStringUTF(hn.getCString());
907 return str;
908 }
909
910 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setHost
911 (JNIEnv *jEnv, jobject jThs, jint jOp, jstring jName) {
912 CIMObjectPath *cop=(CIMObjectPath*)jOp;
913 const char *str=jEnv->GetStringUTFChars(jName,NULL);
914 cop->setHost(String(str));
915 jEnv->ReleaseStringUTFChars(jName,str);
916 }
917
918 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getObjectName
919 (JNIEnv *jEnv, jobject jThs, jint jOp) {
920 CIMObjectPath *cop=(CIMObjectPath*)jOp;
921 const String &cn=cop->getClassName().getString();
922 jstring str=jEnv->NewStringUTF(cn.getCString());
923 return str;
924 }
925 schuur 1.1
926 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setObjectName
927 (JNIEnv *jEnv, jobject jThs, jint jOp, jstring jName) {
928 CIMObjectPath *cop=(CIMObjectPath*)jOp;
929 const char *str=jEnv->GetStringUTFChars(jName,NULL);
930 cop->setClassName(String(str));
931 jEnv->ReleaseStringUTFChars(jName,str);
932 }
933
934 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getNameSpace
935 (JNIEnv *jEnv, jobject jThs, jint jOp) {
936 CIMObjectPath *cop=(CIMObjectPath*)jOp;
937 const String &ns=cop->getNameSpace().getString();
938 jstring str=jEnv->NewStringUTF(ns.getCString());
939 return str;
940 }
941
942 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setNameSpace
943 (JNIEnv *jEnv, jobject jThs, jint jOp, jstring jName) {
944 CIMObjectPath *cop=(CIMObjectPath*)jOp;
945 const char *str=jEnv->GetStringUTFChars(jName,NULL);
946 schuur 1.1 cop->setNameSpace(CIMNamespaceName(str));
947 jEnv->ReleaseStringUTFChars(jName,str);
948 }
949
950 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1addKey
951 (JNIEnv *jEnv, jobject jThs, jint jOp, jstring jId, jint jVal) {
952 CIMObjectPath *cop=(CIMObjectPath*)jOp;
953 const char *str=jEnv->GetStringUTFChars(jId,NULL);
954 CIMValue *cv=(CIMValue*)jVal;
955 Array<CIMKeyBinding> keyBindings=cop->getKeyBindings();
956 keyBindings.append(CIMKeyBinding(str,*cv));
957 cop->setKeyBindings(Array<CIMKeyBinding>(keyBindings));
958 jEnv->ReleaseStringUTFChars(jId,str);
959 return;
960 }
961
962 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeys
963 (JNIEnv *jEnv, jobject jThs, jint jOp, jobject jVec) {
964 CIMObjectPath *cop=(CIMObjectPath*)jOp;
965 const Array<CIMKeyBinding> &akb=cop->getKeyBindings();
966
967 schuur 1.1 for (Uint32 i=0,s=akb.size(); i<s; i++) {
968 const String &n=akb[i].getName().getString();
969 const String &v=akb[i].getValue();
970 CIMKeyBinding::Type t=akb[i].getType();
971 CIMValue *cv;
972 switch (t) {
973 case CIMKeyBinding::NUMERIC:
974 cv=new CIMValue((Sint32)atol(v.getCString()));
975 break;
976 case CIMKeyBinding::STRING:
977 cv=new CIMValue(v);
978 break;
979 case CIMKeyBinding::BOOLEAN:
980 cv=new CIMValue((Boolean)(v.getCString()));
981 break;
982 case CIMKeyBinding::REFERENCE:
983 cv = new CIMValue(CIMObjectPath(akb[i].getValue()));
984 break;
985 default:
986 throwCIMException(jEnv,"+++ unsupported type: ");
987 }
988 schuur 1.1
989 CIMProperty *cp;
990 if(t!=CIMKeyBinding::REFERENCE)
991 cp=new CIMProperty(n,*cv);
992 else cp=new CIMProperty(n,*cv, 0, ((CIMObjectPath) akb[i].getValue()).getClassName());
993
994 jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)cp);
995 jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop);
996 }
997 return jVec;
998 }
999
1000 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeyValue
1001 (JNIEnv *jEnv, jobject jThs, jint jOp, jstring jStr) {
1002 CIMObjectPath *cop=(CIMObjectPath*)jOp;
1003 const Array<CIMKeyBinding> &akb=cop->getKeyBindings();
1004 const char *strKeyName=jEnv->GetStringUTFChars(jStr,NULL);
1005 jstring retStr=NULL;
1006 for (Uint32 i=0,s=akb.size(); i<s; i++) {
1007 const String &n=akb[i].getName().getString();
1008 if (n==String(strKeyName)) {
1009 schuur 1.1 retStr=jEnv->NewStringUTF(akb[i].getValue().getCString());
1010 break;
1011 }
1012 }
1013 jEnv->ReleaseStringUTFChars(jStr,strKeyName);
1014 return retStr;
1015 }
1016
1017 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1set
1018 (JNIEnv *jEnv, jobject jThs, jstring jStr) {
1019 const char *strCop=jEnv->GetStringUTFChars(jStr,NULL);
1020 CIMObjectPath *cop=new CIMObjectPath();
1021 cop->set(String(strCop));
1022 jEnv->ReleaseStringUTFChars(jStr,strCop);
1023 return (jint)cop;
1024 }
1025
1026 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setKeys
1027 (JNIEnv *jEnv, jobject jThs, jint jOp, jobject jVec) {
1028 CIMObjectPath *cop=(CIMObjectPath*)jOp;
1029 Array<CIMKeyBinding> akb;
1030 schuur 1.1 for (Uint32 i=0,s=jEnv->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<s; i++) {
1031 jobject o=jEnv->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,(i));
1032 CIMProperty *cp=(CIMProperty*)jEnv->CallIntMethod(o,JMPIjvm::jv.PropertyCInst);
1033 akb.append(CIMKeyBinding(cp->getName(),cp->getValue()));
1034 }
1035 cop->setKeyBindings(akb);
1036 }
1037
1038 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1clone
1039 (JNIEnv *jEnv, jobject jThs, jint jOp) {
1040 CIMObjectPath *cop=(CIMObjectPath*)jOp;
1041 CIMObjectPath *copl=new CIMObjectPath(cop->getHost(), cop->getNameSpace(), cop->getClassName(), cop->getKeyBindings());
1042 return (jint)(void*)copl;
1043 }
1044
1045 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1toString
1046 (JNIEnv *jEnv, jobject jThs, jint jOp) {
1047 CIMObjectPath *cop=(CIMObjectPath*)jOp;
1048 const String &ns=cop->toString();
1049 jstring str=jEnv->NewStringUTF(ns.getCString());
1050 return str;
1051 schuur 1.1 }
1052
1053
1054 // -------------------------------------
1055 // ---
1056 // - CIMDataType
1057 // ---
1058 // -------------------------------------
1059
1060 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1new
1061 (JNIEnv *jEnv, jobject jThs, jint type) {
1062 return (jint)(void*) new _dataType(type);
1063 }
1064
1065 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newAr
1066 (JNIEnv *jEnv, jobject jThs, jint type, jint size) {
1067 return (jint)(void*) new _dataType(type,size);
1068 }
1069
1070 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newRef
1071 (JNIEnv *jEnv, jobject jThs, jint type, jstring jRef) {
1072 schuur 1.1 const char *ref=jEnv->GetStringUTFChars(jRef,NULL);
1073 jint cInst=(jint)(void*)new _dataType(type,String(ref));
1074 jEnv->ReleaseStringUTFChars(jRef,ref);
1075 return cInst;
1076 }
1077
1078 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isArray
1079 (JNIEnv *jEnv, jobject jThs, jint jDt) {
1080 _dataType *dt=(_dataType*)jDt;
1081 return dt->_array==true;
1082 }
1083
1084 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isreference
1085 (JNIEnv *jEnv, jobject jThs, jint jDt) {
1086 _dataType *dt=(_dataType*)jDt;
1087 return dt->_reference==true;
1088 }
1089
1090 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isReference
1091 (JNIEnv *jEnv, jobject jThs, jint jDt) {
1092 _dataType *dt=(_dataType*)jDt;
1093 schuur 1.1 return dt->_reference==true;
1094 }
1095
1096 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getType
1097 (JNIEnv *jEnv, jobject jThs, jint jDt) {
1098 _dataType *dt=(_dataType*)jDt;
1099 return dt->_type;
1100 }
1101
1102 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getSize
1103 (JNIEnv *jEnv, jobject jThs, jint jDt) {
1104 _dataType *dt=(_dataType*)jDt;
1105 return dt->_size;
1106 }
1107
1108 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1getRefClassName
1109 (JNIEnv *jEnv, jobject jThs, jint jDt) {
1110 _dataType *dt=(_dataType*)jDt;
1111 jstring str=jEnv->NewStringUTF(dt->_refClass.getCString());
1112 return str;
1113 }
1114 schuur 1.1
1115 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1toString
1116 (JNIEnv *jEnv, jobject jThs, jint jDt) {
1117 _dataType *dt=(_dataType*)jDt;
1118 jstring str=NULL;
1119 if (dt->_type & 0x10) {
1120 char tmp[32];
1121 strcpy(tmp,jTypeToChars[dt->_type-0x10]);
1122 strcat(tmp,"[]");
1123 str=jEnv->NewStringUTF(tmp);
1124 }
1125 else if (dt->_type & 0x20) {
1126 String tmp=dt->_refClass+" REF";
1127 str=jEnv->NewStringUTF(tmp.getCString());
1128 }
1129 else {
1130 str=jEnv->NewStringUTF(jTypeToChars[dt->_type]);
1131 }
1132 return str;
1133 }
1134
1135 schuur 1.1
1136
1137 // -------------------------------------
1138 // ---
1139 // - CIMProperty
1140 // ---
1141 // -------------------------------------
1142
1143 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getValue
1144 (JNIEnv *jEnv, jobject jThs, jint jP) {
1145 CIMProperty *cp=(CIMProperty*)jP;
1146 CIMValue *cv=new CIMValue(cp->getValue());
1147 return (jint)cv;
1148 }
1149
1150 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1property
1151 (JNIEnv *jEnv, jobject jThs, jstring jN, jint jV) {
1152 try {
1153 CIMValue *cv=(CIMValue*)jV;
1154 const char *str=jEnv->GetStringUTFChars(jN,NULL);
1155 CIMProperty *cp;
1156 schuur 1.1
1157 if (cv->getType()!=CIMTYPE_REFERENCE)
1158 cp=new CIMProperty(String(str),*cv);
1159 else {
1160 if (!cv->isArray()) {
1161 CIMObjectPath cop;
1162 cv->get(cop);
1163 cp=new CIMProperty(String(str),*cv,0, cop.getClassName());
1164 }
1165 else {
1166 throwCIMException(jEnv,"+++ unsupported type in CIMProperty.property");
1167 }
1168 }
1169
1170 jEnv->ReleaseStringUTFChars(jN,str);
1171 return (jint)cp;
1172 }
1173 Catch(jEnv);
1174 return -1;
1175 }
1176
1177 schuur 1.1 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setValue
1178 (JNIEnv *jEnv, jobject jThs, jint jP,jint jV) {
1179 CIMProperty *cp=(CIMProperty*)jP;
1180 CIMValue *cv=(CIMValue*)jV;
1181 cp->setValue(*cv);
1182 }
1183
1184 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isArray
1185 (JNIEnv *jEnv, jobject jThs, jint jP) {
1186 CIMProperty *cp=(CIMProperty*)jP;
1187 return (jboolean)cp->isArray();
1188 }
1189
1190 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addValue
1191 (JNIEnv *jEnv, jobject jThs, jint jP, jint jV) {
1192 CIMProperty *cp=(CIMProperty*)jP;
1193 CIMValue *cvin=(CIMValue*)jV;
1194 CIMValue cv=cp->getValue();
1195 if (cvin->isNull())
1196 throwCIMException(jEnv,"+++ null cvin value ");
1197 if (!cv.isArray())
1198 schuur 1.1 throwCIMException(jEnv,"+++ not an array ");
1199 if (cvin->getType()!=cv.getType())
1200 throwCIMException(jEnv,"+++ type mismatch ");
1201 CIMType type=cv.getType();
1202 switch (type) {
1203 case CIMTYPE_BOOLEAN: {
1204 Boolean bo;
1205 cvin->get(bo);
1206 Array<Boolean> boarr;
1207 cv.get(boarr);
1208 boarr.append(bo);
1209 }
1210 break;
1211 case CIMTYPE_UINT8: {
1212 Uint8 u8;
1213 cvin->get(u8);
1214 Array<Uint8> u8arr;
1215 cv.get(u8arr);
1216 u8arr.append(u8);
1217 }
1218 break;
1219 schuur 1.1 case CIMTYPE_SINT8: {
1220 Sint8 s8;
1221 cvin->get(s8);
1222 Array<Sint8> s8arr;
1223 cv.get(s8arr);
1224 s8arr.append(s8);
1225 }
1226 break;
1227 case CIMTYPE_UINT16: {
1228 Uint16 u16;
1229 cvin->get(u16);
1230 Array<Uint16> u16arr;
1231 cv.get(u16arr);
1232 u16arr.append(u16);
1233 }
1234 break;
1235 case CIMTYPE_SINT16: {
1236 Sint16 s16;
1237 cvin->get(s16);
1238 Array<Sint16> s16arr;
1239 cv.get(s16arr);
1240 schuur 1.1 s16arr.append(s16);
1241 }
1242 break;
1243 case CIMTYPE_UINT32: {
1244 Uint32 u32;
1245 cvin->get(u32);
1246 Array<Uint32> u32arr;
1247 cv.get(u32arr);
1248 u32arr.append(u32);
1249 }
1250 break;
1251 case CIMTYPE_SINT32: {
1252 Sint32 s32;
1253 cvin->get(s32);
1254 Array<Sint32> s32arr;
1255 cv.get(s32arr);
1256 s32arr.append(s32);
1257 }
1258 break;
1259 case CIMTYPE_UINT64: {
1260 Uint64 u64;
1261 schuur 1.1 cvin->get(u64);
1262 Array<Uint64> u64arr;
1263 cv.get(u64arr);
1264 u64arr.append(u64);
1265 }
1266 break;
1267 case CIMTYPE_SINT64: {
1268 Sint64 s64;
1269 cvin->get(s64);
1270 Array<Sint64> s64arr;
1271 cv.get(s64arr);
1272 s64arr.append(s64);
1273 }
1274 break;
1275 case CIMTYPE_REAL32: {
1276 Real32 f;
1277 cvin->get(f);
1278 Array<Real32> farr;
1279 cv.get(farr);
1280 farr.append(f);
1281 }
1282 schuur 1.1 break;
1283 case CIMTYPE_REAL64: {
1284 Real64 d;
1285 cvin->get(d);
1286 Array<Real64> darr;
1287 cv.get(darr);
1288 darr.append(d);
1289 }
1290 break;
1291 case CIMTYPE_STRING: {
1292 String str;
1293 cvin->get(str);
1294 Array<String> strarr;
1295 cv.get(strarr);
1296 strarr.append(str);
1297 }
1298 break;
1299 case CIMTYPE_REFERENCE: {
1300 CIMObjectPath ref;
1301 cvin->get(ref);
1302 Array<CIMObjectPath> refarr;
1303 schuur 1.1 cv.get(refarr);
1304 refarr.append(ref);
1305 }
1306 break;
1307 default:
1308 throwCIMException(jEnv,"+++ unsupported type ");
1309 }
1310 }
1311
1312 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getName
1313 (JNIEnv *jEnv, jobject jThs, jint jP) {
1314 CIMProperty *cp=(CIMProperty*)jP;
1315 const String &n=cp->getName().getString();
1316 jstring str=jEnv->NewStringUTF(n.getCString());
1317 return str;
1318 }
1319
1320 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isReference
1321 (JNIEnv *jEnv, jobject jThs, jint jP) {
1322 CIMProperty *cp=(CIMProperty*)jP;
1323 return (jboolean)(cp->getType()==CIMTYPE_REFERENCE);
1324 schuur 1.1 }
1325
1326 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getRefClassName
1327 (JNIEnv *jEnv, jobject jThs, jint jP) {
1328 CIMProperty *cp=(CIMProperty*)jP;
1329 const String &n=cp->getReferenceClassName().getString();
1330 jstring str=jEnv->NewStringUTF(n.getCString());
1331 return str;
1332 }
1333
1334 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getType
1335 (JNIEnv *jEnv, jobject jThs, jint jP) {
1336 CIMProperty *cp=(CIMProperty*)jP;
1337 String ref=cp->getReferenceClassName().getString();
1338 _dataType *type=new _dataType(pTypeToJType[cp->getType()],
1339 cp->getArraySize(),
1340 ref.size() ? true : false,
1341 false,
1342 cp->isArray(),
1343 ref,
1344 true);
1345 schuur 1.1 return (jint)type;
1346 }
1347
1348 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMProperty__1getIdentifier
1349 (JNIEnv *jEnv, jobject jThs, jint jP) {
1350 CIMProperty *cp=(CIMProperty*)jP;
1351 const String &n=cp->getName().getString();
1352 jstring str=jEnv->NewStringUTF(n.getCString());
1353 return str;
1354 }
1355
1356 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1finalize
1357 (JNIEnv *jEnv, jobject jThs, jint jP) {
1358 CIMProperty *cp=(CIMProperty*)jP;
1359 delete cp;
1360 }
1361
1362
1363
1364 // -------------------------------------
1365 // ---
1366 schuur 1.1 // - CIMQualifier
1367 // ---
1368 // -------------------------------------
1369
1370 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1finalize
1371 (JNIEnv *jEnv, jobject jThs, jint jQ) {
1372 CIMQualifier *cq=(CIMQualifier*)jQ;
1373 delete cq;
1374 }
1375
1376
1377 // -------------------------------------
1378 // ---
1379 // - CIMDateTime
1380 // ---
1381 // -------------------------------------
1382
1383 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetime
1384 (JNIEnv *jEnv, jobject jThs, jstring jN) {
1385 const char *str=jEnv->GetStringUTFChars(jN,NULL);
1386 CIMDateTime *dt;
1387 schuur 1.1 if (strlen(str)==0)
1388 dt=new CIMDateTime();
1389 else
1390 dt=new CIMDateTime(String(str));
1391 jEnv->ReleaseStringUTFChars(jN,str);
1392 return (jint)dt;
1393 }
1394
1395 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetimeempty
1396 (JNIEnv *jEnv, jobject jThs) {
1397 CIMDateTime *dt=new CIMDateTime(CIMDateTime::getCurrentDateTime ());
1398 return (jint)dt;
1399 }
1400
1401 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1after
1402 (JNIEnv *jEnv, jobject jThs, jint jC, jint jD) {
1403 CIMDateTime *ct = (CIMDateTime *) jC;
1404 CIMDateTime *dt = (CIMDateTime *) jD;
1405 return (jboolean)(ct->getDifference(*ct, *dt)>0);
1406 }
1407
1408 schuur 1.1 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDateTime__1finalize
1409 (JNIEnv *jEnv, jobject jThs, jint jDT) {
1410 CIMDateTime *cdt = (CIMDateTime *) jDT;
1411 delete cdt;
1412 }
1413
1414
1415 // -------------------------------------
1416 // ---
1417 // - CIMMethod
1418 // ---
1419 // -------------------------------------
1420
1421 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1getType
1422 (JNIEnv *jEnv, jobject jThs, jint jM) {
1423 CIMMethod *cm=(CIMMethod*)jM;
1424 return (jint)cm->getType();
1425 }
1426
1427 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize
1428 (JNIEnv *jEnv, jobject jThs, jint jM) {
1429 schuur 1.1 CIMMethod *cm=(CIMMethod*)jM;
1430 delete cm;
1431 }
1432
1433
1434 // -------------------------------------
1435 // ---
1436 // - CIMValue
1437 // ---
1438 // -------------------------------------
1439
1440
1441 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byte
1442 (JNIEnv *jEnv, jobject jThs, jbyte jb, jboolean notSigned) {
1443 CIMValue *cv=NULL;
1444 if (notSigned) cv=new CIMValue((Uint8)jb);
1445 else cv=new CIMValue((Sint8)jb);
1446 return (jint)cv;
1447 }
1448
1449 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1short
1450 schuur 1.1 (JNIEnv *jEnv, jobject jThs, jshort js, jboolean notSigned) {
1451 CIMValue *cv=NULL;
1452 if (notSigned) cv=new CIMValue((Uint16)js);
1453 else cv=new CIMValue((Sint16)js);
1454 return (jint)cv;
1455 }
1456
1457 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue_makeInt
1458 (JNIEnv *jEnv, jobject jThs, jlong ji, jboolean notSigned) {
1459 CIMValue *cv=NULL;
1460 if (notSigned) cv=new CIMValue((Uint32)ji);
1461 else cv=new CIMValue((Sint32)ji);
1462 return (jint)cv;
1463 }
1464
1465 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1long
1466 (JNIEnv *jEnv, jobject jThs, jlong jl, jboolean notSigned) {
1467 CIMValue *cv=NULL;
1468 if (notSigned) cv=new CIMValue((Uint64)jl);
1469 else cv=new CIMValue((Sint64)jl);
1470 return (jint)cv;
1471 schuur 1.1 }
1472
1473 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1float
1474 (JNIEnv *jEnv, jobject jThs, jfloat jF) {
1475 CIMValue *cv=new CIMValue(jF);
1476 return (jint)cv;
1477 }
1478
1479 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1double
1480 (JNIEnv *jEnv, jobject jThs, jdouble jD) {
1481 CIMValue *cv=new CIMValue(jD);
1482 return (jint)cv;
1483 }
1484
1485 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1string
1486 (JNIEnv *jEnv, jobject jThs, jstring jS) {
1487 const char *str=jEnv->GetStringUTFChars(jS,NULL);
1488 CIMValue *cv=new CIMValue(String(str));
1489 jEnv->ReleaseStringUTFChars(jS,str);
1490 return (jint)cv;
1491 }
1492 schuur 1.1
1493 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1ref
1494 (JNIEnv *jEnv, jobject jThs, jint jR) {
1495 CIMObjectPath *ref=(CIMObjectPath*)jR;
1496 CIMValue *cv=new CIMValue(*ref);
1497 return (jint)cv;
1498 }
1499
1500 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1datetime
1501 (JNIEnv *jEnv, jobject jThs, jint jDT) {
1502 CIMDateTime *dt=(CIMDateTime*)jDT;
1503 CIMValue *cv=new CIMValue(*dt);
1504 return (jint)cv;
1505 }
1506
1507 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMValue__1isArray
1508 (JNIEnv *jEnv, jobject jThs, jint jP) {
1509 CIMValue *cv=(CIMValue*)jP;
1510 return (jboolean)cv->isArray();
1511 }
1512
1513 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1boolean
1514 (JNIEnv *jEnv, jobject jThs, jboolean jB) {
1515 CIMValue *cv=new CIMValue((Boolean)jB);
1516 return (jint)cv;
1517 }
1518
1519 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byteArray
1520 (JNIEnv *jEnv, jobject jThs, jshortArray jshortA, jboolean notSigned) {
1521 CIMValue *cv=NULL;
1522 jboolean b;
1523 jsize len=jEnv->GetArrayLength(jshortA);
1524 jshort* jsA=jEnv->GetShortArrayElements(jshortA,&b);
1525 if (notSigned) {
1526 Array<Uint8> u8;
1527 for (jsize i=0;i<len;i++)
1528 u8.append((Uint8)jsA[i]);
1529 cv=new CIMValue(u8);
1530 }
1531 else {
1532 Array<Sint8> s8;
1533 for (jsize i=0;i<len;i++)
1534 schuur 1.1 s8.append((Sint8)jsA[i]);
1535 cv=new CIMValue(s8);
1536 }
1537 return (jint)(void*)cv;
1538 }
1539
1540 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1shortArray
1541 (JNIEnv *jEnv, jobject jThs, jintArray jintA, jboolean notSigned) {
1542 CIMValue *cv=NULL;
1543 jboolean b;
1544 jsize len=jEnv->GetArrayLength(jintA);
1545 jint* jiA=jEnv->GetIntArrayElements(jintA,&b);
1546 if (notSigned) {
1547 Array<Uint16> u16;
1548 for (jsize i=0;i<len;i++)
1549 u16.append((Uint16)jiA[i]);
1550 cv=new CIMValue(u16);
1551 }
1552 else {
1553 Array<Sint16> s16;
1554 for (jsize i=0;i<len;i++)
1555 schuur 1.1 s16.append((Sint16)jiA[i]);
1556 cv=new CIMValue(s16);
1557 }
1558 return (jint)(void*)cv;
1559 }
1560
1561 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1intArray
1562 (JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned) {
1563 CIMValue *cv=NULL;
1564 jboolean b;
1565 jsize len=jEnv->GetArrayLength(jlongA);
1566 jlong* jlA=jEnv->GetLongArrayElements(jlongA,&b);
1567 if (notSigned) {
1568 Array<Uint32> u32;
1569 for (jsize i=0;i<len;i++)
1570 u32.append((Uint32)jlA[i]);
1571 cv=new CIMValue(u32);
1572 }
1573 else {
1574 Array<Sint32> s32;
1575 for (jsize i=0;i<len;i++)
1576 schuur 1.1 s32.append((Sint32)jlA[i]);
1577 cv=new CIMValue(s32);
1578 }
1579 return (jint)(void*)cv;
1580 }
1581
1582 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1longArray
1583 (JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned) {
1584 CIMValue *cv=NULL;
1585 jboolean b;
1586 jsize len=jEnv->GetArrayLength(jlongA);
1587 jlong* jlA=jEnv->GetLongArrayElements(jlongA,&b);
1588 if (notSigned) {
1589 Array<Uint64> u64;
1590 for (jsize i=0;i<len;i++)
1591 u64.append((Uint64)jlA[i]);
1592 cv=new CIMValue(u64);
1593 }
1594 else {
1595 Array<Sint64> s64;
1596 for (jsize i=0;i<len;i++)
1597 schuur 1.1 s64.append((Sint64)jlA[i]);
1598 cv=new CIMValue(s64);
1599 }
1600 return (jint)(void*)cv;
1601 }
1602
1603 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1stringArray
1604 (JNIEnv *jEnv, jobject jThs, jobjectArray jstringA) {
1605 CIMValue *cv=NULL;
1606 jboolean b;
1607 jsize len=jEnv->GetArrayLength(jstringA);
1608 Array<String> strA;
1609
1610 for (jsize i=0;i<len;i++) {
1611 jstring jsA=(jstring)jEnv->GetObjectArrayElement(jstringA,i);
1612 const char *str=jEnv->GetStringUTFChars(jsA,NULL);
1613 strA.append(String(str));
1614 jEnv->ReleaseStringUTFChars(jsA,str);
1615 }
1616
1617 cv=new CIMValue(strA);
1618 schuur 1.1 return (jint)(void*)cv;
1619 }
1620
1621 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1booleanArray
1622 (JNIEnv *jEnv, jobject jThs, jbooleanArray jboolA) {
1623 CIMValue *cv=NULL;
1624 jboolean b;
1625 jsize len=jEnv->GetArrayLength(jboolA);
1626 jboolean* jbA=jEnv->GetBooleanArrayElements(jboolA,&b);
1627 Array<Boolean> bA;
1628 for (jsize i=0;i<len;i++)
1629 bA.append((Boolean)jbA[i]);
1630 cv=new CIMValue(bA);
1631 return (jint)(void*)cv;
1632 }
1633
1634 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1refArray
1635 (JNIEnv *jEnv, jobject jThs, jintArray jintA) {
1636 CIMValue *cv=NULL;
1637 jboolean b;
1638 jsize len=jEnv->GetArrayLength(jintA);
1639 schuur 1.1 jint* jiA=jEnv->GetIntArrayElements(jintA,&b);
1640 Array<CIMObjectPath> cA;
1641 for (jsize i=0;i<len;i++)
1642 cA.append(*((CIMObjectPath*)jiA[i]));
1643 cv=new CIMValue(cA);
1644 return (jint)(void*)cv;
1645 }
1646
1647 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType
1648 (JNIEnv *jEnv, jobject jThs, jint jP) {
1649 CIMValue *cv=(CIMValue*)jP;
1650 return (jint)cv->getType();
1651 }
1652
1653 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString
1654 (JNIEnv *jEnv, jobject jThs, jint jV) {
1655 CIMValue *cv=(CIMValue*)jV;
1656 return (jstring)jEnv->NewStringUTF(cv->toString().getCString());
1657 }
1658
1659 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMValue__1getValue
1660 schuur 1.1 (JNIEnv *jEnv, jobject jThs, jint jV) {
1661 CIMValue *cv=(CIMValue*)jV;
1662 if (cv->isNull())
1663 return NULL;
1664 CIMType type=cv->getType();
1665
1666 if (!cv->isArray()) {
1667 switch (type) {
1668 case CIMTYPE_BOOLEAN:
1669 Boolean bo;
1670 cv->get(bo);
1671 return jEnv->NewObject(classRefs[1],instanceMethodIDs[1],bo);
1672 break;
1673 case CIMTYPE_SINT8:
1674 Sint8 s8;
1675 cv->get(s8);
1676 return jEnv->NewObject(classRefs[2],instanceMethodIDs[2],s8);
1677 break;
1678 case CIMTYPE_UINT8:
1679 Uint8 u8;
1680 cv->get(u8);
1681 schuur 1.1 return jEnv->NewObject(classRefs[8],instanceMethodIDs[8],u8);
1682 break;
1683 case CIMTYPE_SINT16:
1684 Sint16 s16;
1685 cv->get(s16);
1686 return jEnv->NewObject(classRefs[3],instanceMethodIDs[3],s16);
1687 break;
1688 case CIMTYPE_UINT16:
1689 Uint16 u16;
1690 cv->get(u16);
1691 return jEnv->NewObject(classRefs[9],instanceMethodIDs[9],u16);
1692 break;
1693 case CIMTYPE_SINT32:
1694 Sint32 s32;
1695 cv->get(s32);
1696 return jEnv->NewObject(classRefs[4],instanceMethodIDs[4],s32);
1697 break;
1698 case CIMTYPE_UINT32:
1699 Uint32 u32;
1700 cv->get(u32);
1701 return jEnv->NewObject(classRefs[10],instanceMethodIDs[10],u32);
1702 schuur 1.1 break;
1703 case CIMTYPE_SINT64:
1704 Sint64 s64;
1705 cv->get(s64);
1706 return jEnv->NewObject(classRefs[5],instanceMethodIDs[5],s64);
1707 break;
1708 case CIMTYPE_UINT64: {
1709 Uint64 u64;
1710 cv->get(u64);
1711 jobject big=jEnv->CallStaticObjectMethod(classRefs[14],staticMethodIDs[0],u64);
1712 return jEnv->NewObject(classRefs[11],instanceMethodIDs[11],big);
1713 }
1714 break;
1715 case CIMTYPE_REAL32:
1716 float f;
1717 cv->get(f);
1718 return jEnv->NewObject(classRefs[6],instanceMethodIDs[6],f);
1719 break;
1720 case CIMTYPE_REAL64:
1721 double d;
1722 cv->get(d);
1723 schuur 1.1 return jEnv->NewObject(classRefs[7],instanceMethodIDs[7],d);
1724 break;
1725 case CIMTYPE_STRING: {
1726 String s;
1727 jstring str;
1728 cv->get(s);
1729 str=jEnv->NewStringUTF(s.getCString());
1730 return str;
1731 }
1732 break;
1733 case CIMTYPE_REFERENCE: {
1734 CIMObjectPath ref;
1735 cv->get(ref);
1736 return jEnv->NewObject(classRefs[12],instanceMethodIDs[12],
1737 (jint)new CIMObjectPath(ref));
1738 }
1739 break;
1740 case CIMTYPE_CHAR16:
1741 throwCIMException(jEnv,"+++ Char16 not yet supported");
1742 break;
1743 case CIMTYPE_DATETIME: {
1744 schuur 1.1 CIMDateTime dt;
1745 cv->get(dt);
1746 return jEnv->NewObject(classRefs[24],instanceMethodIDs[35],
1747 (jint)new CIMDateTime(dt));
1748 }
1749 // throwCIMException(jEnv,"+++ DateTime not yet supported");
1750 break;
1751 default:
1752 throwCIMException(jEnv,"+++ unsupported type: ");
1753 }
1754 }
1755
1756 else {
1757 switch (type) {
1758 case CIMTYPE_BOOLEAN: {
1759 Array<Boolean> bo;
1760 cv->get(bo);
1761 int s=bo.size();
1762 jobjectArray jbooleanA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[1],0);
1763 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jbooleanA, i,
1764 jEnv->NewObject(classRefs[1],instanceMethodIDs[1],bo[i]));
1765 schuur 1.1 return jbooleanA;
1766 }
1767 break;
1768 case CIMTYPE_SINT8: {
1769 Array<Sint8> s8;
1770 cv->get(s8);
1771 int s=s8.size();
1772 jobjectArray jbyteA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[2],0);
1773 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jbyteA, i,
1774 jEnv->NewObject(classRefs[2],instanceMethodIDs[2],s8[i]));
1775 return jbyteA;
1776 }
1777 break;
1778 case CIMTYPE_UINT8: {
1779 Array<Uint8> u8;
1780 cv->get(u8);
1781 int s=u8.size();
1782 jobjectArray jshortA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[8],0);
1783 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jshortA, i,
1784 jEnv->NewObject(classRefs[8],instanceMethodIDs[8],u8[i]));
1785 return jshortA;
1786 schuur 1.1 }
1787 break;
1788 case CIMTYPE_SINT16: {
1789 Array<Sint16> s16;
1790 cv->get(s16);
1791 int s=s16.size();
1792 jobjectArray jshortA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[3],0);
1793 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jshortA, i,
1794 jEnv->NewObject(classRefs[3],instanceMethodIDs[3],s16[i]));
1795 return jshortA;
1796 }
1797 break;
1798 case CIMTYPE_UINT16: {
1799 Array<Uint16> u16;
1800 cv->get(u16);
1801 int s=u16.size();
1802 jobjectArray jintA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[9],0);
1803 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jintA, i,
1804 jEnv->NewObject(classRefs[9],instanceMethodIDs[9],u16[i]));
1805 return jintA;
1806 }
1807 schuur 1.1 break;
1808 case CIMTYPE_SINT32: {
1809 Array<Sint32> s32;
1810 cv->get(s32);
1811 int s=s32.size();
1812 jobjectArray jintA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[4],0);
1813 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jintA, i,
1814 jEnv->NewObject(classRefs[4],instanceMethodIDs[4],s32[i]));
1815 return jintA;
1816 }
1817 break;
1818 case CIMTYPE_UINT32: {
1819 Array<Uint32> u32;
1820 cv->get(u32);
1821 int s=u32.size();
1822 jobjectArray jlongA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[10],0);
1823 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jlongA, i,
1824 jEnv->NewObject(classRefs[10],instanceMethodIDs[10],u32[i]));
1825 return jlongA;
1826 }
1827 break;
1828 schuur 1.1 case CIMTYPE_SINT64: {
1829 Array<Sint64> s64;
1830 cv->get(s64);
1831 int s=s64.size();
1832 jobjectArray jlongA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[5],0);
1833 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jlongA, i,
1834 jEnv->NewObject(classRefs[5],instanceMethodIDs[5],s64[i]));
1835 return jlongA;
1836 }
1837 break;
1838 case CIMTYPE_UINT64:
1839 throwCIMException(jEnv,"+++ UnisgnetInt64 not yet supported");
1840 break;
1841 case CIMTYPE_REAL32: {
1842 Array<Real32> r32;
1843 cv->get(r32);
1844 int s=r32.size();
1845 jobjectArray jfloatA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[6],0);
1846 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jfloatA, i,
1847 jEnv->NewObject(classRefs[6],instanceMethodIDs[6],r32[i]));
1848 return jfloatA;
1849 schuur 1.1 }
1850 break;
1851 case CIMTYPE_REAL64: {
1852 Array<Real64> r64;
1853 cv->get(r64);
1854 int s=r64.size();
1855 jobjectArray jdoubleA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[7],0);
1856 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jdoubleA, i,
1857 jEnv->NewObject(classRefs[7],instanceMethodIDs[7],r64[i]));
1858 return jdoubleA;
1859 }
1860 break;
1861 case CIMTYPE_STRING: {
1862 Array<String> str;
1863 cv->get(str);
1864 int s=str.size();
1865 jobjectArray jstringA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[22],0);
1866 for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jstringA, i,
1867 jEnv->NewStringUTF(str[i].getCString()));
1868 return jstringA;
1869 }
1870 schuur 1.1 break;
1871 case CIMTYPE_REFERENCE:
1872 throwCIMException(jEnv,"+++ Reference not yet supported");
1873 break;
1874 case CIMTYPE_CHAR16:
1875 throwCIMException(jEnv,"+++ Char16 not yet supported");
1876 break;
1877 case CIMTYPE_DATETIME:
1878 throwCIMException(jEnv,"+++ DateTime not yet supported");
1879 break;
1880 default:
1881 throwCIMException(jEnv,"+++ unsupported type: ");
1882 }
1883 }
1884 return NULL;
1885 }
1886
1887 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMValue__1finalize
1888 (JNIEnv *jEnv, jobject jThs, jint jV) {
1889 CIMValue *cv=(CIMValue*)jV;
1890 delete cv;
1891 schuur 1.1 }
1892
1893
1894 // -------------------------------------
1895 // ---
1896 // - CIMNameSpace
1897 // ---
1898 // -------------------------------------
1899
1900 _nameSpace::_nameSpace() {
1901 port_=0;
1902 hostName_=System::getHostName();
1903 nameSpace_="root/cimv2";
1904 }
1905
1906 _nameSpace::_nameSpace(String hn) {
1907 port_=0;
1908 hostName_=hn;
1909 nameSpace_="root/cimv2";
1910 }
1911
1912 schuur 1.1 _nameSpace::_nameSpace(String hn, String ns) {
1913 port_=0;
1914 hostName_=hn;
1915 nameSpace_=ns;
1916 }
1917
1918 int _nameSpace::port() {
1919 if (port_) return port_;
1920 port_=5988;
1921 if (hostName_.subString(0,7)=="http://") {
1922 protocol_="http://";
1923 hostName_=hostName_.subString(7);
1924 }
1925 Sint32 p=hostName_.reverseFind(':');
1926 if (p>=0) {
1927 if (isdigit(hostName_[p+1]))
1928 port_=atoi(hostName_.subString(p+1).getCString());
1929 hostName_.remove(p);
1930 }
1931 return port_;
1932 }
1933 schuur 1.1
1934 String _nameSpace::hostName() {
1935 port();
1936 return hostName_;
1937 }
1938
1939 String _nameSpace::nameSpace() {
1940 return nameSpace_;
1941 }
1942
1943
1944 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1new
1945 (JNIEnv *jEnv, jobject jThs) {
1946 return (jint)(void*) new _nameSpace();
1947 }
1948
1949 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHn
1950 (JNIEnv *jEnv, jobject jThs, jstring jHn) {
1951 const char *hn=jEnv->GetStringUTFChars(jHn,NULL);
1952 jint cInst=(jint)(void*)new _nameSpace(hn);
1953 jEnv->ReleaseStringUTFChars(jHn,hn);
1954 schuur 1.1 return cInst;
1955 }
1956
1957 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHnNs
1958 (JNIEnv *jEnv, jobject jThs, jstring jHn, jstring jNs) {
1959 const char *hn=jEnv->GetStringUTFChars(jHn,NULL);
1960 const char *ns=jEnv->GetStringUTFChars(jNs,NULL);
1961 jint cInst=(jint)(void*)new _nameSpace(String(hn),String(ns));
1962 jEnv->ReleaseStringUTFChars(jHn,hn);
1963 jEnv->ReleaseStringUTFChars(jNs,ns);
1964 return cInst;
1965 }
1966
1967 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getHost
1968 (JNIEnv *jEnv, jobject jThs, jint jNs) {
1969 _nameSpace *cNs=(_nameSpace*)jNs;
1970 const String &hn=cNs->hostName_;
1971 jstring str=jEnv->NewStringUTF(hn.getCString());
1972 return str;
1973 }
1974
1975 schuur 1.1 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getNameSpace
1976 (JNIEnv *jEnv, jobject jThs, jint jNs) {
1977 _nameSpace *cNs=(_nameSpace*)jNs;
1978 const String &ns=cNs->nameSpace_;
1979 jstring str=jEnv->NewStringUTF(ns.getCString());
1980 return str;
1981 }
1982
1983 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setHost
1984 (JNIEnv *jEnv, jobject jThs, jint jNs, jstring jHn) {
1985 _nameSpace *cNs=(_nameSpace*)jNs;
1986 const char *str=jEnv->GetStringUTFChars(jHn,NULL);
1987 cNs->port_=0;
1988 cNs->hostName_=str;
1989 jEnv->ReleaseStringUTFChars(jHn,str);
1990 }
1991
1992 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setNameSpace
1993 (JNIEnv *jEnv, jobject jThs, jint jNs, jstring jN) {
1994 _nameSpace *cNs=(_nameSpace*)jN;
1995 const char *str=jEnv->GetStringUTFChars(jN,NULL);
1996 schuur 1.1 cNs->nameSpace_=str;
1997 jEnv->ReleaseStringUTFChars(jN,str);
1998 }
1999
2000
2001 // -------------------------------------
2002 // ---
2003 // - Enumerators
2004 // ---
2005 // -------------------------------------
2006
2007
2008 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1getInstance
2009 (JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) {
2010 Array<CIMInstance> *enm=(Array<CIMInstance>*)jEnum;
2011 return (jint) new CIMInstance((*enm)[pos]);
2012 }
2013
2014 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1size
2015 (JNIEnv *jEnv, jobject jThs, jint jEnum) {
2016 Array<CIMInstance> *enm=(Array<CIMInstance>*)jEnum;
2017 schuur 1.1 return enm->size();
2018 }
2019
2020
2021 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1getObjectPath
2022 (JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) {
2023 Array<CIMObjectPath> *enm=(Array<CIMObjectPath>*)jEnum;
2024 return (jint) new CIMObjectPath((*enm)[pos]);
2025 }
2026
2027 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1size
2028 (JNIEnv *jEnv, jobject jThs, jint jEnum) {
2029 Array<CIMObjectPath> *enm=(Array<CIMObjectPath>*)jEnum;
2030 return enm->size();
2031 }
2032
2033 // -------------------------------------
2034 // ---
2035 // - CIMClient
2036 // ---
2037 // -------------------------------------
2038 schuur 1.1
2039 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1newNaUnPw
2040 (JNIEnv *jEnv, jobject jThs, jint jNs, jstring jUn, jstring jPw) {
2041 _nameSpace *cNs=(_nameSpace*)jNs;
2042
2043 const char *un=jEnv->GetStringUTFChars(jUn,NULL);
2044 const char *pw=jEnv->GetStringUTFChars(jPw,NULL);
2045
2046 try {
2047 CIMClient *cc=new CIMClient();
2048 cc->connect(cNs->hostName(),cNs->port(),un,pw);
2049 jEnv->ReleaseStringUTFChars(jUn,un);
2050 jEnv->ReleaseStringUTFChars(jPw,pw);
2051 cout<<"### connect ok "<<(jint)(void*)cc<<endl;
2052 return (jint)(void*)cc;
2053 }
2054 catch (CIMException e) {
2055 jEnv->ReleaseStringUTFChars(jUn,un);
2056 jEnv->ReleaseStringUTFChars(jPw,pw);
2057 throwCimException(jEnv,e);
2058 }
2059 schuur 1.1 catch (...) {
2060 jEnv->ReleaseStringUTFChars(jUn,un);
2061 jEnv->ReleaseStringUTFChars(jPw,pw);
2062 throwFailedException(jEnv);
2063 }
2064 return 0;
2065 }
2066
2067 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1disconnect
2068 (JNIEnv *jEnv, jobject jThs, jint jCc) {
2069 CIMClient *cCc=(CIMClient*)jCc;
2070 try {
2071 cCc->disconnect();
2072 }
2073 catch (CIMException e) {
2074 throwCimException(jEnv,e);
2075 }
2076 }
2077
2078 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getClass
2079 (JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jboolean lo) {
2080 schuur 1.1 CIMClient *cCc=(CIMClient*)jCc;
2081 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2082 try {
2083 CIMClass cls=cCc->getClass(cop->getNameSpace(),cop->getClassName(),(Boolean)lo);
2084 return (jint) new CIMClass(cls);
2085 }
2086 catch (CIMException e) {
2087 throwCimException(jEnv,e);
2088 }
2089 return 0;
2090 }
2091
2092 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getInstance
2093 (JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jboolean lo) {
2094 CIMClient *cCc=(CIMClient*)jCc;
2095 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2096 try {
2097 CIMInstance inst=cCc->getInstance(cop->getNameSpace(),*cop,(Boolean)lo);
2098 return (jint) new CIMInstance(inst);
2099 }
2100 catch (CIMException e) {
2101 schuur 1.1 throwCimException(jEnv,e);
2102 }
2103 return 0;
2104 }
2105
2106 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstances
2107 (JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jboolean deep, jboolean lo) {
2108 CIMClient *cCc=(CIMClient*)jCc;
2109 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2110 try {
2111 Array<CIMInstance> enm=cCc->enumerateInstances(
2112 cop->getNameSpace(),cop->getClassName(),(Boolean)deep,(Boolean)lo);
2113 return (jint) new Array<CIMInstance>(enm);
2114 }
2115 catch (CIMException e) {
2116 throwCimException(jEnv,e);
2117 }
2118 return 0;
2119 }
2120
2121 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstanceNames
2122 schuur 1.1 (JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jboolean deep) {
2123 CIMClient *cCc=(CIMClient*)jCc;
2124 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2125 try {
2126 Array<CIMObjectPath> enm=cCc->enumerateInstanceNames(
2127 cop->getNameSpace(),cop->getClassName()); //,(Boolean)deep);
2128 return (jint) new Array<CIMObjectPath>(enm);
2129 }
2130 catch (CIMException e) {
2131 throwCimException(jEnv,e);
2132 }
2133 return 0;
2134 }
2135
2136 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1createInstance
2137 (JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, int jCi) {
2138 CIMClient *cCc=(CIMClient*)jCc;
2139 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2140 CIMInstance *ci=(CIMInstance*)jCi;
2141
2142 try {
2143 schuur 1.1 CIMObjectPath obj=cCc->createInstance(cop->getNameSpace(),*ci);
2144 return (jint) new CIMObjectPath(obj);
2145 }
2146 catch (CIMException e) {
2147 throwCimException(jEnv,e);
2148 }
2149 return 0;
2150 }
2151
2152 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setInstance
2153 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jint jCi) {
2154 CIMClient *cCc=(CIMClient*)jCc;
2155 CIMObjectPath *cop=(CIMObjectPath*)jCop;
2156 CIMInstance *ci=(CIMInstance*)jCi;
2157
2158 try {
2159 cCc->modifyInstance(cop->getNameSpace(),*ci);
2160 }
2161 catch (CIMException e) {
2162 throwCimException(jEnv,e);
2163 }
2164 schuur 1.1 return ;
2165 }
2166
2167 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty
2168 (JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jstring jPn) {
2169 throwNotSupportedException(jEnv);
2170 return 0;
2171 }
2172
2173 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty
2174 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jstring jPn, jint jV) {
2175 throwNotSupportedException(jEnv);
2176 return;
2177 }
2178
2179 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteInstance
2180 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop) {
2181 throwNotSupportedException(jEnv);
2182 return;
2183 }
2184
2185 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery
2186 (JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jstring jQuery, jstring jQl) {
2187 throwNotSupportedException(jEnv);
2188 return 0;
2189 }
2190
2191 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associatorNames
2192 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop,
2193 jstring assocClass, jstring resultClass, jstring role, jstring resultRole) {
2194 throwNotSupportedException(jEnv);
2195 return 0;
2196 }
2197
2198 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associators
2199 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop,
2200 jstring assocClass, jstring resultClass, jstring role, jstring resultRole,
2201 jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray propertyList) {
2202 throwNotSupportedException(jEnv);
2203 return 0;
2204 }
2205
2206 schuur 1.1 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1referenceNames
2207 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop,
2208 jstring assocClass, jstring resultClass) {
2209 throwNotSupportedException(jEnv);
2210 return 0;
2211 }
2212
2213 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1references
2214 (JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop,
2215 jstring assocClass, jstring resultClass,
2216 jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray propertyList) {
2217 throwNotSupportedException(jEnv);
2218 return 0;
2219 }
2220
2221 } // extern "C"
2222
2223 PEGASUS_NAMESPACE_END
2224
2225
2226
2227 schuur 1.1
2228
2229
2230
|
Return to
JMPIImpl.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI