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