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