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