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