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