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