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