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