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