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