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