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