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