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