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