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