version 1.41, 2006/05/12 19:49:14
|
version 1.86, 2008/12/15 16:01:50
|
|
|
//%2006//////////////////////////////////////////////////////////////////////// |
//%LICENSE//////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
// Licensed to The Open Group (TOG) under one or more contributor license |
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. |
// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with |
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.; |
// this work for additional information regarding copyright ownership. |
// IBM Corp.; EMC Corporation, The Open Group. |
// Each contributor licenses this file to you under the OpenPegasus Open |
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; |
// Source License; you may not use this file except in compliance with the |
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
// License. |
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; VERITAS Software Corporation; The Open Group. |
|
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; Symantec Corporation; The Open Group. |
|
// | // |
// Permission is hereby granted, free of charge, to any person obtaining a copy |
// Permission is hereby granted, free of charge, to any person obtaining a |
// of this software and associated documentation files (the "Software"), to |
// copy of this software and associated documentation files (the "Software"), |
// deal in the Software without restriction, including without limitation the |
// to deal in the Software without restriction, including without limitation |
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
// the rights to use, copy, modify, merge, publish, distribute, sublicense, |
// sell copies of the Software, and to permit persons to whom the Software is |
// and/or sell copies of the Software, and to permit persons to whom the |
// furnished to do so, subject to the following conditions: |
// Software is furnished to do so, subject to the following conditions: |
// | // |
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN |
// The above copyright notice and this permission notice shall be included |
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED |
// in all copies or substantial portions of the Software. |
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT |
|
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR |
|
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
|
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
|
// | // |
//============================================================================== |
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
|
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
|
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
|
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
|
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
// | // |
// Author: Adrian Schuur, schuur@de.ibm.com |
////////////////////////////////////////////////////////////////////////// |
// |
|
// Modified By: Adrian Dutta |
|
// Andy Viciu |
|
// Magda Vacarelu |
|
// David Dillard, VERITAS Software Corp. |
|
// (david.dillard@veritas.com) |
|
// Mark Hamzy, hamzy@us.ibm.com |
|
// | // |
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
|
|
#include "JMPIImpl.h" | #include "JMPIImpl.h" |
| |
#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC) |
#if defined(PEGASUS_OS_TYPE_WINDOWS) |
#include <Pegasus/Common/DynamicLibrary.h> | #include <Pegasus/Common/DynamicLibrary.h> |
#else | #else |
#include <dlfcn.h> | #include <dlfcn.h> |
|
|
#include <Pegasus/Common/CIMObjectPath.h> | #include <Pegasus/Common/CIMObjectPath.h> |
#include <Pegasus/Common/CIMProperty.h> | #include <Pegasus/Common/CIMProperty.h> |
#include <Pegasus/Common/OperationContext.h> | #include <Pegasus/Common/OperationContext.h> |
|
#include <Pegasus/Common/Tracer.h> |
#include <Pegasus/Provider/CIMOMHandle.h> | #include <Pegasus/Provider/CIMOMHandle.h> |
#include <Pegasus/Client/CIMClient.h> | #include <Pegasus/Client/CIMClient.h> |
#include <Pegasus/ProviderManager2/JMPI/JMPIProviderManager.h> | #include <Pegasus/ProviderManager2/JMPI/JMPIProviderManager.h> |
#include <Pegasus/ProviderManager2/CMPI/CMPI_SelectExp.h> |
#include <Pegasus/WQL/WQLSelectStatement.h> |
|
#include <Pegasus/WQL/WQLParser.h> |
|
#define CALL_SIGN_WQL "WQL" |
| |
PEGASUS_USING_STD; | PEGASUS_USING_STD; |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
JavaVM *JMPIjvm::jvm=NULL; | JavaVM *JMPIjvm::jvm=NULL; |
JvmVector JMPIjvm::jv; | JvmVector JMPIjvm::jv; |
int JMPIjvm::trace=0; |
|
|
|
#ifdef PEGASUS_DEBUG |
|
#define DDD(x) if (JMPIjvm::trace) x; |
|
#else |
|
#define DDD(x) |
|
#endif |
|
| |
#include "Convert.h" | #include "Convert.h" |
| |
|
|
/*32*/ "java/lang/Character", | /*32*/ "java/lang/Character", |
/*33*/ "org/pegasus/jmpi/OperationContext", | /*33*/ "org/pegasus/jmpi/OperationContext", |
/*34*/ "java/lang/Class", | /*34*/ "java/lang/Class", |
|
/*35*/ "java/io/ByteArrayOutputStream", |
|
/*36*/ "java/io/PrintStream" |
}; | }; |
| |
const METHOD_STRUCT instanceMethodNames[]={ | const METHOD_STRUCT instanceMethodNames[]={ |
/*00 VectorNew */ { /*Vector */ 0, "<init>", "()V" }, |
/*00 VectorNew */ |
/*01 BooleanNewZ */ { /*Boolean */ 1, "<init>", "(Z)V" }, |
{ /*Vector */ |
/*02 ByteNewB */ { /*Byte */ 2, "<init>", "(B)V" }, |
0, |
/*03 ShortNewS */ { /*Short */ 3, "<init>", "(S)V" }, |
"<init>", |
/*04 IntegerNewI */ { /*Integer */ 4, "<init>", "(I)V" }, |
"()V" }, |
/*05 LongNewJ */ { /*Long */ 5, "<init>", "(J)V" }, |
/*01 BooleanNewZ */ |
/*06 FloatNewF */ { /*Float */ 6, "<init>", "(F)V" }, |
{ /*Boolean */ |
/*07 DoubleNewD */ { /*Double */ 7, "<init>", "(D)V" }, |
1, |
/*08 UnsignedInt8NewS */ { /*UnsignedInt8 */ 8, "<init>", "(S)V" }, |
"<init>", |
/*09 UnsignedInt16NewI */ { /*UnsignedInt16 */ 9, "<init>", "(I)V" }, |
"(Z)V" }, |
/*10 UnsignedInt32NewJ */ { /*UnsignedInt32 */10, "<init>", "(J)V" }, |
/*02 ByteNewB */ |
/*11 UnsignedInt64NewBi */ { /*UnsignedInt64 */11, "<init>", "(Ljava/math/BigInteger;)V" }, |
{ /*Byte */ |
/*12 CIMObjectPathNewI */ { /*CIMObjectPath */12, "<init>", "(I)V" }, |
2, |
/*13 CIMExceptionNewSt */ { /*CIMException */13, "<init>", "(Ljava/lang/String;)V" }, |
"<init>", |
/*14 CIMPropertyNewI */ { /*CIMProperty */15, "<init>", "(I)V" }, |
"(B)V" }, |
/*15 VectorAddElement */ { /*Vector */ 0, "addElement", "(Ljava/lang/Object;)V" }, |
/*03 ShortNewS */ |
/*16 VectorElementAt */ { /*Vector */ 0, "elementAt", "(I)Ljava/lang/Object;" }, |
{ /*Short */ |
/*17 CIMOMHandleNewISt */ { /*CIMOMHandle */16, "<init>", "(ILjava/lang/String;)V" }, |
3, |
/*18 CIMExceptionNewI */ { /*CIMException */13, "<init>", "(I)V" }, |
"<init>", |
/*19 CIMClassNewI */ { /*CIMClass */17, "<init>", "(I)V" }, |
"(S)V" }, |
/*20 CIMInstanceNewI */ { /*CIMInstance */18, "<init>", "(I)V" }, |
/*04 IntegerNewI */ |
/*21 CIMObjectPathCInst */ { /*CIMObjectPath */12, "cInst", "()I" }, |
{ /*Integer */ |
/*22 CIMInstanceCInst */ { /*CIMInstance */18, "cInst", "()I" }, |
4, |
/*23 CIMClassCInst */ { /*CIMClass */17, "cInst", "()I" }, |
"<init>", |
/*24 ObjectToString */ { /*Object */20, "toString", "()Ljava/lang/String;" }, |
"(I)V" }, |
/*25 ThrowableGetMessage */ { /*Throwable */21, "getMessage", "()Ljava/lang/String;" }, |
/*05 LongNewJ */ |
/*26 CIMExceptionGetID */ { /*CIMException */13, "getID", "()Ljava/lang/String;" }, |
{ /*Long */ |
/*27 VectorSize */ { /*Vector */ 0, "size", "()I" }, |
5, |
/*28 CIMPropertyCInst */ { /*CIMProperty */15, "cInst", "()I" }, |
"<init>", |
/*29 CIMOMHandleGetClass */ { /*CIMOMHandle */16, "getClass", "(Lorg/pegasus/jmpi/CIMObjectPath;Z)Lorg/pegasus/jmpi/CIMClass;" }, |
"(J)V" }, |
/*30 VectorRemoveElementAt */ { /*Vector */ 0, "removeElementAt", "(I)V" }, |
/*06 FloatNewF */ |
/*31 CIMValueCInst */ { /*CIMValue */19, "cInst", "()I" }, |
{ /*Float */ |
/*32 CIMExceptionNewISt */ { /*CIMException */13, "<init>", "(ILjava/lang/String;)V" }, |
6, |
/*33 CIMExceptionGetCode */ { /*CIMException */13, "getCode", "()I" }, |
"<init>", |
/*34 CIMDateTimeNewI */ { /*CIMDateTime */24, "<init>", "(I)V" }, |
"(F)V" }, |
/*35 SelectExpNewI */ { /*SelectExp */25, "<init>", "(I)V" }, |
/*07 DoubleNewD */ |
/*36 CIMQualifierNewI */ { /*CIMQualifier */26, "<init>", "(I)V" }, |
{ /*Double */ |
/*37 CIMFlavorNewI */ { /*CIMFlavor */28, "<init>", "(I)V" }, |
7, |
/*38 CIMFlavorGetFlavor */ { /*CIMFlavor */28, "getFlavor", "()I" }, |
"<init>", |
/*39 CIMArgumentCInst */ { /*CIMArgument */29, "cInst", "()I" }, |
"(D)V" }, |
/*40 CIMArgumentNewI */ { /*CIMArgument */29, "<init>", "(I)V" }, |
/*08 UnsignedInt8NewS */ |
/*41 CIMExceptionNew */ { /*CIMException */13, "<init>", "()V" }, |
{ /*UnsignedInt8 */ |
/*42 CIMExceptionNewStOb */ { /*CIMException */13, "<init>", "(Ljava/lang/String;Ljava/lang/Object;)V" }, |
8, |
/*43 CIMExceptionNewStObOb */ { /*CIMException */13, "<init>", "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)V" }, |
"<init>", |
/*44 CIMExceptionNewStObObOb */ { /*CIMException */13, "<init>", "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V" }, |
"(S)V" }, |
/*45 CIMValueNewI */ { /*CIMValue */19, "<init>", "(I)V" }, |
/*09 UnsignedInt16NewI */ |
/*46 CIMObjectNewIZ */ { /*CIMObject */31, "<init>", "(IZ)V" }, |
{ /*UnsignedInt16 */ |
/*47 CharacterNewC */ { /*Character */32, "<init>", "(C)V" }, |
9, |
/*48 OperationContextNewI */ { /*OperationContext */33, "<init>", "(I)V" }, |
"<init>", |
/*49 OperationContextUnassociate */ { /*OperationContext */33, "unassociate", "()V" }, |
"(I)V" }, |
/*50 ClassGetInterfaces */ { /*Class */34, "getInterfaces", "()[Ljava/lang/Class;" }, |
/*10 UnsignedInt32NewJ */ |
/*51 ClassGetName */ { /*Class */34, "getName", "()Ljava/lang/String;" }, |
{ /*UnsignedInt32 */ |
|
10, |
|
"<init>", |
|
"(J)V" }, |
|
/*11 UnsignedInt64NewBi */ |
|
{ /*UnsignedInt64 */ |
|
11, |
|
"<init>", |
|
"(Ljava/math/BigInteger;)V" }, |
|
/*12 CIMObjectPathNewJ */ |
|
{ /*CIMObjectPath */ |
|
12, |
|
"<init>", |
|
"(J)V" }, |
|
/*13 CIMExceptionNewSt */ |
|
{ /*CIMException */ |
|
13, |
|
"<init>", |
|
"(Ljava/lang/String;)V" }, |
|
/*14 CIMPropertyNewJ */ |
|
{ /*CIMProperty */ |
|
15, |
|
"<init>", |
|
"(J)V" }, |
|
/*15 VectorAddElement */ |
|
{ /*Vector */ |
|
0, |
|
"addElement", |
|
"(Ljava/lang/Object;)V" }, |
|
/*16 VectorElementAt */ |
|
{ /*Vector */ |
|
0, |
|
"elementAt", |
|
"(I)Ljava/lang/Object;" }, |
|
/*17 CIMOMHandleNewJSt */ |
|
{ /*CIMOMHandle */ |
|
16, |
|
"<init>", |
|
"(JLjava/lang/String;)V" }, |
|
/*18 CIMExceptionNewI */ |
|
{ /*CIMException */ |
|
13, |
|
"<init>", |
|
"(I)V" }, |
|
/*19 CIMClassNewJ */ |
|
{ /*CIMClass */ |
|
17, |
|
"<init>", |
|
"(J)V" }, |
|
/*20 CIMInstanceNewJ */ |
|
{ /*CIMInstance */ |
|
18, |
|
"<init>", |
|
"(J)V" }, |
|
/*21 CIMObjectPathCInst */ |
|
{ /*CIMObjectPath */ |
|
12, |
|
"cInst", |
|
"()J" }, |
|
/*22 CIMInstanceCInst */ |
|
{ /*CIMInstance */ |
|
18, |
|
"cInst", |
|
"()J" }, |
|
/*23 CIMClassCInst */ |
|
{ /*CIMClass */ |
|
17, |
|
"cInst", |
|
"()J" }, |
|
/*24 ObjectToString */ |
|
{ /*Object */ |
|
20, |
|
"toString", |
|
"()Ljava/lang/String;" }, |
|
/*25 ThrowableGetMessage */ |
|
{ /*Throwable */ |
|
21, |
|
"getMessage", |
|
"()Ljava/lang/String;" }, |
|
/*26 CIMExceptionGetID */ |
|
{ /*CIMException */ |
|
13, |
|
"getID", |
|
"()Ljava/lang/String;" }, |
|
/*27 VectorSize */ |
|
{ /*Vector */ |
|
0, |
|
"size", |
|
"()I" }, |
|
/*28 CIMPropertyCInst */ |
|
{ /*CIMProperty */ |
|
15, |
|
"cInst", |
|
"()J" }, |
|
/*29 CIMOMHandleGetClass */ |
|
{ /*CIMOMHandle */ |
|
16, |
|
"getClass", |
|
"(Lorg/pegasus/jmpi/CIMObjectPath;Z)Lorg/pegasus/jmpi/CIMClass;" }, |
|
/*30 VectorRemoveElementAt */ |
|
{ /*Vector */ |
|
0, |
|
"removeElementAt", |
|
"(I)V" }, |
|
/*31 CIMValueCInst */ |
|
{ /*CIMValue */ |
|
19, |
|
"cInst", |
|
"()J" }, |
|
/*32 CIMExceptionNewISt */ |
|
{ /*CIMException */ |
|
13, |
|
"<init>", |
|
"(ILjava/lang/String;)V" }, |
|
/*33 CIMExceptionGetCode */ |
|
{ /*CIMException */ |
|
13, |
|
"getCode", |
|
"()I" }, |
|
/*34 CIMDateTimeNewJ */ |
|
{ /*CIMDateTime */ |
|
24, |
|
"<init>", |
|
"(J)V" }, |
|
/*35 SelectExpNewJ */ |
|
{ /*SelectExp */ |
|
25, |
|
"<init>", |
|
"(J)V" }, |
|
/*36 CIMQualifierNewJ */ |
|
{ /*CIMQualifier */ |
|
26, |
|
"<init>", |
|
"(J)V" }, |
|
/*37 CIMFlavorNewI */ |
|
{ /*CIMFlavor */ |
|
28, |
|
"<init>", |
|
"(I)V" }, |
|
/*38 CIMFlavorGetFlavor */ |
|
{ /*CIMFlavor */ |
|
28, |
|
"getFlavor", |
|
"()I" }, |
|
/*39 CIMArgumentCInst */ |
|
{ /*CIMArgument */ |
|
29, |
|
"cInst", |
|
"()J" }, |
|
/*40 CIMArgumentNewJ */ |
|
{ /*CIMArgument */ |
|
29, |
|
"<init>", |
|
"(J)V" }, |
|
/*41 CIMExceptionNew */ |
|
{ /*CIMException */ |
|
13, |
|
"<init>", |
|
"()V" }, |
|
/*42 CIMExceptionNewStOb */ |
|
{ /*CIMException */ |
|
13, |
|
"<init>", |
|
"(Ljava/lang/String;Ljava/lang/Object;)V" }, |
|
/*43 CIMExceptionNewStObOb */ |
|
{ /*CIMException */ |
|
13, |
|
"<init>", |
|
"(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)V" }, |
|
/*44 CIMExceptionNewStObObOb */ |
|
{ /*CIMException */ |
|
13, |
|
"<init>", |
|
"(Ljava/lang/String;Ljava/lang/Object;" |
|
"Ljava/lang/Object;Ljava/lang/Object;)V" }, |
|
/*45 CIMValueNewJ */ |
|
{ /*CIMValue */ |
|
19, |
|
"<init>", |
|
"(J)V" }, |
|
/*46 CIMObjectNewJZ */ |
|
{ /*CIMObject */ |
|
31, |
|
"<init>", |
|
"(JZ)V" }, |
|
/*47 CharacterNewC */ |
|
{ /*Character */ |
|
32, |
|
"<init>", |
|
"(C)V" }, |
|
/*48 OperationContextNewJ */ |
|
{ /*OperationContext */ |
|
33, |
|
"<init>", |
|
"(J)V" }, |
|
/*49 OperationContextUnassociate */ |
|
{ /*OperationContext */ |
|
33, |
|
"unassociate", |
|
"()V" }, |
|
/*50 ClassGetInterfaces */ |
|
{ /*Class */ |
|
34, |
|
"getInterfaces", |
|
"()[Ljava/lang/Class;" }, |
|
/*51 ClassGetName */ |
|
{ /*Class */ |
|
34, |
|
"getName", |
|
"()Ljava/lang/String;" }, |
|
/*52 UnsignedInt64NewStr */ |
|
{ /*UnsignedInt64 */ |
|
11, |
|
"<init>", |
|
"(Ljava/lang/String;)V" }, |
|
/*53 ByteArrayOutputStreamNew */ |
|
{ /*ByteArrayOutputStream */ |
|
35, |
|
"<init>", |
|
"()V" }, |
|
/*54 PrintStreamNewOb */ |
|
{ /*PrintStreamNew */ |
|
36, |
|
"<init>", |
|
"(Ljava/io/OutputStream;)V" }, |
|
/*55 ThrowablePrintStackTrace */ |
|
{ /*Throwable */ |
|
21, |
|
"printStackTrace", |
|
"(Ljava/io/PrintStream;)V" }, |
|
/*56 ByteArrayOutputStreamToString */ |
|
{ /*ByteArrayOutputStream */ |
|
35, |
|
"toString", |
|
"()Ljava/lang/String;" } |
}; | }; |
| |
const METHOD_STRUCT staticMethodNames[]={ | const METHOD_STRUCT staticMethodNames[]={ |
/*00*/ { 14, "valueOf", "(J)Ljava/math/BigInteger;" }, |
/*00*/ { 14, |
/*01*/ { 23, "load", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Class;" }, |
"valueOf", |
|
"(J)Ljava/math/BigInteger;" }, |
|
/*01*/ { 23, |
|
"load", |
|
"(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Class;" }, |
}; | }; |
| |
static int methodInitDone=0; | static int methodInitDone=0; |
| |
jclass classRefs[sizeof(classNames)/sizeof(classNames[0])]; | jclass classRefs[sizeof(classNames)/sizeof(classNames[0])]; |
jmethodID instanceMethodIDs[sizeof(instanceMethodNames)/sizeof(instanceMethodNames[0])]; |
jmethodID instanceMethodIDs[sizeof(instanceMethodNames) / |
jmethodID staticMethodIDs[sizeof(staticMethodNames)/sizeof(staticMethodNames[0])]; |
sizeof(instanceMethodNames[0])]; |
|
jmethodID staticMethodIDs[sizeof(staticMethodNames) / |
|
sizeof(staticMethodNames[0])]; |
| |
jclass JMPIjvm::getGlobalClassRef(JNIEnv *env, const char* name) | jclass JMPIjvm::getGlobalClassRef(JNIEnv *env, const char* name) |
{ | { |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIjvm::getGlobalClassRef"); |
|
|
jclass localRefCls=env->FindClass(name); | jclass localRefCls=env->FindClass(name); |
| |
if (localRefCls==NULL) | if (localRefCls==NULL) |
|
{ |
|
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"No local Class reference found. (localRefCls==NULL)"); |
|
PEG_METHOD_EXIT(); |
return JNI_FALSE; | return JNI_FALSE; |
|
} |
|
|
| |
jclass globalRefCls=(jclass) env->NewGlobalRef(localRefCls); | jclass globalRefCls=(jclass) env->NewGlobalRef(localRefCls); |
| |
#if 0 | #if 0 |
jmethodID jmidToString = env->GetMethodID(globalRefCls, "toString", "()Ljava/lang/String;"); |
jmethodID jmidToString = env->GetMethodID(globalRefCls, |
jstring jstringResult = (jstring)env->CallObjectMethod(globalRefCls, jmidToString); |
"toString", |
|
"()Ljava/lang/String;"); |
|
jstring jstringResult = (jstring)env->CallObjectMethod(globalRefCls, |
|
jmidToString); |
const char *pszResult = env->GetStringUTFChars(jstringResult, 0); | const char *pszResult = env->GetStringUTFChars(jstringResult, 0); |
| |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getGlobalClassRef: globalRefCls = "<<PEGASUS_STD(hex)<<(int)globalRefCls<<PEGASUS_STD(dec)<<", name = "<<name<<", pszResult = "<<pszResult<<PEGASUS_STD(endl)); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"globalRefCls = %p, name = %s, pszResult = %s", |
|
globalRefCls,name,pszResult)); |
| |
env->ReleaseStringUTFChars (jstringResult, pszResult); | env->ReleaseStringUTFChars (jstringResult, pszResult); |
#else | #else |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getGlobalClassRef: globalRefCls = "<<PEGASUS_STD(hex)<<(int)globalRefCls<<PEGASUS_STD(dec)<<", name = "<<name<<PEGASUS_STD(endl)); |
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"globalRefCls = %p, name = %s",globalRefCls,name)); |
|
|
#endif | #endif |
| |
env->DeleteLocalRef(localRefCls); | env->DeleteLocalRef(localRefCls); |
| |
|
PEG_METHOD_EXIT(); |
return globalRefCls; | return globalRefCls; |
} | } |
| |
|
|
| |
int JMPIjvm::cacheIDs(JNIEnv *env) | int JMPIjvm::cacheIDs(JNIEnv *env) |
{ | { |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIjvm::cacheIDs"); |
|
|
if (methodInitDone==1) | if (methodInitDone==1) |
|
{ |
|
PEG_METHOD_EXIT(); |
return JNI_TRUE; | return JNI_TRUE; |
|
} |
|
|
if (methodInitDone==-1) | if (methodInitDone==-1) |
|
{ |
|
PEG_METHOD_EXIT(); |
return JNI_FALSE; | return JNI_FALSE; |
|
} |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): enter"<<PEGASUS_STD(endl)); |
|
| |
methodInitDone=-1; | methodInitDone=-1; |
| |
for (unsigned i=0; i<(sizeof(classNames)/sizeof(classNames[0])); i++) { |
for (unsigned i = 0; i<(sizeof(classNames)/sizeof(classNames[0])); i++) |
//////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<classNames[i]<<PEGASUS_STD(endl)); |
{ |
if ((classRefs[i]=getGlobalClassRef(env,classNames[i]))==NULL) | if ((classRefs[i]=getGlobalClassRef(env,classNames[i]))==NULL) |
{ | { |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error: Count not find global class ref for "<<classNames[i]<<PEGASUS_STD(endl)); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Error: Count not find global class ref for %s",classNames[i])); |
| |
|
PEG_METHOD_EXIT(); |
return JNI_FALSE; | return JNI_FALSE; |
} | } |
} | } |
| |
for (unsigned j=0; j<(sizeof(instanceMethodNames)/sizeof(instanceMethodNames[0])); j++) { |
unsigned instanceMethodNamesSize = |
//////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<j<<": "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<": "<<instanceMethodNames[j].signature<<PEGASUS_STD(endl)); |
sizeof(instanceMethodNames)/sizeof(instanceMethodNames[0]); |
if ((instanceMethodIDs[j]=env->GetMethodID(classRefs[instanceMethodNames[j].clsIndex], |
|
|
for (unsigned j = 0; j<instanceMethodNamesSize; j++) |
|
{ |
|
instanceMethodIDs[j] = env->GetMethodID( |
|
classRefs[instanceMethodNames[j].clsIndex], |
instanceMethodNames[j].methodName, | instanceMethodNames[j].methodName, |
instanceMethodNames[j].signature))==NULL) |
instanceMethodNames[j].signature); |
|
if (instanceMethodIDs[j] == NULL) |
{ | { |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error could not get method id for "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<PEGASUS_STD(endl)); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Error: Could not get instance method id for %s:%s", |
|
classNames[instanceMethodNames[j].clsIndex], |
|
instanceMethodNames[j].methodName)); |
|
|
|
PEG_METHOD_EXIT(); |
return 0; | return 0; |
} | } |
} | } |
|
unsigned staticMethodNamesSize = |
for (unsigned k=0; k<(sizeof(staticMethodNames)/sizeof(staticMethodNames[0])); k++) { |
sizeof(staticMethodNames) / sizeof(staticMethodNames[0]); |
//////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<k<<": "<<classNames[staticMethodNames[k].clsIndex]<<": "<<staticMethodNames[k].methodName<<": "<<staticMethodNames[k].signature<<PEGASUS_STD(endl)); |
for (unsigned k = 0; k<staticMethodNamesSize; k++) |
if ((staticMethodIDs[k]=env->GetStaticMethodID(classRefs[staticMethodNames[k].clsIndex], |
{ |
|
staticMethodIDs[k] = env->GetStaticMethodID( |
|
classRefs[staticMethodNames[k].clsIndex], |
staticMethodNames[k].methodName, | staticMethodNames[k].methodName, |
staticMethodNames[k].signature))==NULL) |
staticMethodNames[k].signature); |
|
|
|
if (staticMethodIDs[k] == NULL) |
{ | { |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error could not get method id for "<<classNames[staticMethodNames[k].clsIndex]<<": "<<staticMethodNames[k].methodName<<PEGASUS_STD(endl)); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Error: Could not get static method id for %s:%s", |
|
classNames[staticMethodNames[k].clsIndex], |
|
staticMethodNames[k].methodName)); |
|
|
|
PEG_METHOD_EXIT(); |
return 0; | return 0; |
} | } |
} | } |
| |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): exit"<<PEGASUS_STD(endl)); |
|
|
|
jv.env=env; | jv.env=env; |
jv.classRefs=classRefs; | jv.classRefs=classRefs; |
jv.instMethodIDs=instanceMethodIDs; | jv.instMethodIDs=instanceMethodIDs; |
|
|
| |
methodInitDone=1; | methodInitDone=1; |
| |
|
PEG_METHOD_EXIT(); |
return JNI_TRUE; | return JNI_TRUE; |
} | } |
| |
|
|
| |
int JMPIjvm::destroyJVM() | int JMPIjvm::destroyJVM() |
{ | { |
DDD(PEGASUS_STD(cerr)<<"--- JPIjvm::destroyJVM()"<<PEGASUS_STD(endl)); |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JPIjvm::destroyJVM"); |
| |
#ifdef JAVA_DESTROY_VM_WORKS | #ifdef JAVA_DESTROY_VM_WORKS |
if (jvm!=NULL) { |
if (jvm!= NULL) |
|
{ |
JvmVector *jv; | JvmVector *jv; |
| |
attachThread(&jv); | attachThread(&jv); |
|
|
| |
jvm = NULL; | jvm = NULL; |
| |
|
PEG_METHOD_EXIT(); |
return 0; | return 0; |
} | } |
#endif | #endif |
| |
|
PEG_METHOD_EXIT(); |
return -1; | return -1; |
} | } |
| |
|
|
| |
int JMPIjvm::initJVM () | int JMPIjvm::initJVM () |
{ | { |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JPIjvm::initJVM"); |
|
|
AutoMutex lock (_initMutex); | AutoMutex lock (_initMutex); |
| |
if (jvm != NULL) | if (jvm != NULL) |
|
|
}; | }; |
std::ostringstream oss; | std::ostringstream oss; |
| |
#ifdef PEGASUS_DEBUG |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
if (getenv("PEGASUS_JMPI_TRACE")) JMPIjvm::trace=1; |
"Start to initialize the JVM."); |
else JMPIjvm::trace=0; |
|
#else |
|
JMPIjvm::trace=0; |
|
#endif |
|
|
|
DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM()" << PEGASUS_STD(endl)); |
|
| |
jv.initRc=0; | jv.initRc=0; |
| |
envstring=getenv("CLASSPATH"); | envstring=getenv("CLASSPATH"); |
if (envstring==NULL) { |
if (envstring == NULL) |
|
{ |
jv.initRc=1; | jv.initRc=1; |
| |
DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): No CLASSPATH environment variable found" << PEGASUS_STD(endl)); |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
|
"No CLASSPATH environment variable found."); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L( |
|
CIM_ERR_FAILED, |
|
MessageLoaderParms( |
|
"ProviderManager2.JMPI.JMPIImpl.GET_CLASSPATH_FAILED.STANDARD", |
|
"Could not get CLASSPATH from environment.") |
|
); |
| |
return -1; | return -1; |
} | } |
|
|
///JNIoptions.append ("-Djava.compiler=NONE"); | ///JNIoptions.append ("-Djava.compiler=NONE"); |
///maxoption++; | ///maxoption++; |
| |
for (Uint32 i = 0; i < (int)(sizeof (aEnvOptions)/sizeof (aEnvOptions[0])); i++) |
unsigned int aEnvOptionsSize=sizeof(aEnvOptions)/sizeof(aEnvOptions[0]); |
|
for (Uint32 i = 0; i < aEnvOptionsSize; i++) |
{ | { |
JVMOPTIONS *pEnvOption = &aEnvOptions[i]; | JVMOPTIONS *pEnvOption = &aEnvOptions[i]; |
| |
|
|
while (fCommaFound) | while (fCommaFound) |
{ | { |
string stringValue; | string stringValue; |
string::size_type posComma = stringValues.find (',', posStart); |
string::size_type posComma = stringValues.find(',', |
|
posStart); |
| |
if (posComma != string::npos) | if (posComma != string::npos) |
{ | { |
|
|
stringValue = stringValues.substr (posStart, posEnd - posStart + 1); | stringValue = stringValues.substr (posStart, posEnd - posStart + 1); |
} | } |
| |
DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): fCommaFound = " << fCommaFound << ", posStart = " << posStart << ", posComma = " << posComma << ", posEnd = " << posEnd << "" << PEGASUS_STD(endl)); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
|
"fCommaFound = %d, posStart = %d, " |
|
"posComma = %d, posEnd = %d", |
|
fCommaFound,posStart,posComma,posEnd)); |
| |
maxoption++; | maxoption++; |
| |
|
|
| |
JNIoptions.append (oss.str ()); | JNIoptions.append (oss.str ()); |
| |
DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): " << pEnvOption->pszEnvName << " found! Specifying \"" << oss.str () << "\"" << PEGASUS_STD(endl)); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
|
"%s found! Specifying \"%s\"", |
|
pEnvOption->pszEnvName, (const char*)oss.str().c_str())); |
} | } |
} | } |
else | else |
|
|
| |
JNIoptions.append (oss.str ()); | JNIoptions.append (oss.str ()); |
| |
DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): " << pEnvOption->pszEnvName << " found! Specifying \"" << oss.str () << "\"" << PEGASUS_STD(endl)); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"%s found! Specifying \"%s\"", |
|
pEnvOption->pszEnvName, (const char*)oss.str().c_str())); |
|
|
} | } |
} | } |
} | } |
|
|
{ | { |
jv.initRc=1; | jv.initRc=1; |
| |
DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): Could not allocate " << maxoption << " structures of size " << sizeof (JavaVMOption) << PEGASUS_STD(endl)); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2, |
|
"Could not allocate %d structures of size %d.", |
|
maxoption,sizeof (JavaVMOption))); |
| |
|
PEG_METHOD_EXIT(); |
return -1; | return -1; |
} | } |
| |
|
|
{ | { |
poptions[i].optionString = (char *)JNIoptions[i].c_str (); | poptions[i].optionString = (char *)JNIoptions[i].c_str (); |
| |
DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): Setting option " << i << " to \"" << poptions[i].optionString << "\"" << PEGASUS_STD(endl)); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
|
"Setting option %d to \"%s\".", |
|
i ,poptions[i].optionString)); |
} | } |
| |
vm_args.version=JNI_VERSION_1_2; | vm_args.version=JNI_VERSION_1_2; |
|
|
free (poptions); | free (poptions); |
} | } |
| |
if (res!=0) { |
if (res!= 0) |
|
{ |
jv.initRc=1; | jv.initRc=1; |
| |
DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): Can not create Java VM"<<PEGASUS_STD(endl)); |
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3, |
|
"Can not create Java VM !"); |
| |
|
PEG_METHOD_EXIT(); |
return -1; | return -1; |
} | } |
| |
cacheIDs(env); | cacheIDs(env); |
| |
if (env->ExceptionOccurred()) { |
if (env->ExceptionOccurred()) |
|
{ |
jv.initRc=1; | jv.initRc=1; |
| |
env->ExceptionDescribe(); | env->ExceptionDescribe(); |
|
|
jvm = NULL; | jvm = NULL; |
#endif | #endif |
| |
|
PEG_METHOD_EXIT(); |
return -1; | return -1; |
} | } |
| |
jv.initRc=1; | jv.initRc=1; |
jv.jvm=jvm; | jv.jvm=jvm; |
| |
|
PEG_METHOD_EXIT(); |
return res; | return res; |
} | } |
| |
JNIEnv* JMPIjvm::attachThread(JvmVector **jvp) | JNIEnv* JMPIjvm::attachThread(JvmVector **jvp) |
{ | { |
JNIEnv* env = NULL; | JNIEnv* env = NULL; |
|
int rc; |
| |
if (jvm == NULL) | if (jvm == NULL) |
{ | { |
initJVM (); |
rc = initJVM (); |
| |
if (jvm == NULL) |
if ((jvm == NULL) || (rc != 0)) |
return NULL; | return NULL; |
} | } |
| |
|
|
jvm->DetachCurrentThread(); | jvm->DetachCurrentThread(); |
} | } |
| |
jobject JMPIjvm::getProvider(JNIEnv *env, String jar, String cln, |
jobject JMPIjvm::getProvider (JNIEnv *env, |
const char *cn, jclass *cls) |
String jarName, |
|
String className, |
|
const char *pszProviderName, |
|
jclass *pjClass) |
|
{ |
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIjvm::getProvider"); |
|
|
|
jobject jProviderInstance = 0; |
|
jclass jClassLoaded = 0; |
|
jmethodID jId = 0; |
|
jobject jProviderInstanceLocal = 0; |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"jarName = %s, className = %s, pszProviderName = %s, pjClass = %p", |
|
(const char*)jarName.getCString(), |
|
(const char*)className.getCString(), |
|
pszProviderName,pjClass)); |
|
|
|
// CASE #1 |
|
// className has been loaded previously. |
|
// Return saved instance. |
|
_objectTable.lookup (className, jProviderInstance); |
|
_classTable.lookup (className, jClassLoaded); |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"jProviderInstance = %p, jClassLoaded = %p", |
|
jProviderInstance,jClassLoaded)); |
|
|
|
if ( jProviderInstance |
|
&& jClassLoaded |
|
) |
{ | { |
jobject gProv=NULL; |
if (pjClass) |
jclass scls=NULL; |
{ |
|
*pjClass = jClassLoaded; |
|
} |
|
PEG_METHOD_EXIT(); |
|
return jProviderInstance; |
|
} |
| |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jar = "<<jar<<", cln = "<<cln<<", cn = "<<cn<<", cls = "<<cls<<PEGASUS_STD(endl)); |
// CASE #2 |
|
// className can be loaded via getGlobalClassRef (). |
|
// Load and return the instance. |
|
// NOTE: |
|
// According to |
|
// http://java.sun.com/j2se/1.5.0/docs/guide/jni/spec/functions.html |
|
// In JDK 1.1, FindClass searched only local classes in CLASSPATH. |
| |
_objectTable.lookup(cln,gProv); |
jClassLoaded = getGlobalClassRef (env, |
_classTable.lookup(cln,scls); |
(const char*)className.getCString ()); |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(int)gProv<<", scls = "<<(int)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
|
| |
if (gProv) { |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
*cls=scls; |
"jClassLoaded = %p",jClassLoaded)); |
return gProv; |
|
|
if (env->ExceptionCheck ()) |
|
{ |
|
// CASE #3 |
|
// see if the className can be loaded via JarClassLoader.load (). |
|
// Load and return the instance. |
|
jstring jJarName = 0; |
|
jstring jClassName = 0; |
|
jclass jClassLoadedLocal = 0; |
|
|
|
env->ExceptionClear (); |
|
|
|
// NOTE: Instances of "packageName/className" will not work with the jar |
|
// class loader. Change the '/' to a '.'. |
|
String fixedClassName(className); |
|
static Char16 slash=Char16('/'); |
|
|
|
for (Uint32 i=0; i<className.size(); i++) |
|
{ |
|
if (fixedClassName[i]==slash) |
|
{ |
|
fixedClassName[i]=Char16('.'); |
} | } |
|
}; |
| |
/* |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
DDD(PEGASUS_STD(cout)<<"--- jar: "<<jar<<PEGASUS_STD(endl)); |
"fixedClassName = %s",(const char*)fixedClassName.getCString())); |
DDD(PEGASUS_STD(cout)<<"--- cln: "<<cln<<PEGASUS_STD(endl)); |
|
|
jJarName = env->NewStringUTF((const char*)jarName.getCString()); |
|
jClassName = env->NewStringUTF((const char*)fixedClassName.getCString()); |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"jJarName = %p, jClassName = %p", |
|
jJarName,jClassName)); |
|
|
|
jClassLoadedLocal = (jclass)env->CallStaticObjectMethod( |
|
JMPIjvm::jv.JarClassLoaderClassRef, |
|
JMPIjvm::jv.JarClassLoaderLoad, |
|
jJarName, |
|
jClassName); |
| |
jstring jjar=env->NewStringUTF((const char*)jar.getCString()); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
jstring jcln=env->NewStringUTF((const char*)cln.getCString()); |
"jClassLoadedLocal = %p",jClassLoadedLocal)); |
| |
jclass jcls=(jclass)env->CallStaticObjectMethod(JMPIjvm::jv.JarClassLoaderRef,jv.JarClassLoaderLoad, |
if (env->ExceptionCheck ()) |
jjar,jcln); |
{ |
if (env->ExceptionCheck()) { |
|
env->ExceptionDescribe(); | env->ExceptionDescribe(); |
PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<cn<<PEGASUS_STD(endl); |
|
////////return NULL; |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
|
"Unable to instantiate provider %s: " |
|
"Can not load Java class %s from jar %s.", |
|
pszProviderName, |
|
(const char*)fixedClassName.getCString(), |
|
(const char*)jarName.getCString())); |
|
|
|
PEG_METHOD_EXIT(); |
|
return 0; |
} | } |
*/ |
|
| |
scls=getGlobalClassRef(env,(const char*)cln.getCString()); |
jClassLoaded = (jclass)env->NewGlobalRef (jClassLoadedLocal); |
if (env->ExceptionCheck()) { |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::getProvider: Provider "<<cn<<" not found"<<PEGASUS_STD(endl)); |
|
DDD(env->ExceptionDescribe()); |
|
| |
return NULL; |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"jClassLoaded = %p",jClassLoaded)); |
|
|
|
env->DeleteLocalRef (jClassLoadedLocal); |
} | } |
*cls=scls; |
|
| |
if (scls) |
if (pjClass) |
{ | { |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: scls = "<<PEGASUS_STD(hex)<<(int)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
*pjClass = jClassLoaded; |
_classTable.insert(cln,scls); |
|
} | } |
| |
jmethodID id=env->GetMethodID(*cls,"<init>","()V"); |
if (!jClassLoaded) |
jobject lProv=env->NewObject(*cls,id); |
{ |
gProv=(jobject)env->NewGlobalRef(lProv); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
if (env->ExceptionCheck()) { |
"Unable to instantiate provider %s: " |
DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<cn<<PEGASUS_STD(endl)); |
"Can not load Java class.",pszProviderName)); |
return NULL; |
PEG_METHOD_EXIT(); |
|
return 0; |
} | } |
| |
if (gProv) |
jId = env->GetMethodID (jClassLoaded,"<init>","()V"); |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"GetMethodID() jID = %p ",jId)); |
|
|
|
jProviderInstanceLocal = env->NewObject (jClassLoaded, |
|
jId); |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"NewObject() jProviderInstanceLocal = %p ", |
|
jProviderInstanceLocal)); |
|
|
|
if (!jProviderInstanceLocal) |
{ | { |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(int)gProv<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
_objectTable.insert(cln,gProv); |
"Unable to instantiate provider %s: " |
|
"No new Java object of provider.",pszProviderName)); |
|
PEG_METHOD_EXIT(); |
|
return 0; |
} | } |
| |
return gProv; |
jProviderInstance = (jobject)env->NewGlobalRef (jProviderInstanceLocal); |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"NewGlobalRef() jProviderInstance = %p ",jProviderInstance)); |
|
|
|
if (!jProviderInstance) |
|
{ |
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
|
"Unable to instantiate provider %s: " |
|
"No global reference to provider object.",pszProviderName)); |
|
PEG_METHOD_EXIT(); |
|
return 0; |
|
} |
|
|
|
_classTable.insert (className, jClassLoaded); |
|
_objectTable.insert (className, jProviderInstance); |
|
|
|
PEG_METHOD_EXIT(); |
|
return jProviderInstance; |
} | } |
| |
jobject JMPIjvm::getProvider(JNIEnv *env, const char *cn, jclass *cls) | jobject JMPIjvm::getProvider(JNIEnv *env, const char *cn, jclass *cls) |
|
|
jobject gProv=NULL; | jobject gProv=NULL; |
jclass scls=NULL; | jclass scls=NULL; |
| |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: cn = "<<cn<<", cls = "<<cls<<PEGASUS_STD(endl)); |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIjvm::getProvider"); |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"cn = %s, cls = %p",cn,cls)); |
| |
_objectTable.lookup(cln,gProv); | _objectTable.lookup(cln,gProv); |
_classTable.lookup(cln,scls); | _classTable.lookup(cln,scls); |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(int)gProv<<", scls = "<<(int)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
|
| |
if (gProv) { |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"gProv = %p, scls = %p",gProv,scls)); |
|
|
|
if (gProv) |
|
{ |
*cls=scls; | *cls=scls; |
return gProv; | return gProv; |
} | } |
| |
scls=getGlobalClassRef(env,cn); | scls=getGlobalClassRef(env,cn); |
if (env->ExceptionCheck()) { |
if (env->ExceptionCheck()) |
DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::getProvider: Provider "<<cn<<" not found"<<PEGASUS_STD(endl)); |
{ |
DDD(env->ExceptionDescribe()); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
|
"Provider %s not found: No global reference.",cn)); |
|
PEG_METHOD_EXIT(); |
return NULL; | return NULL; |
} | } |
*cls=scls; | *cls=scls; |
| |
if (scls) | if (scls) |
{ | { |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: scls = "<<PEGASUS_STD(hex)<<(int)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Inserting global reference %p into class table.",scls)); |
_classTable.insert(cln,scls); | _classTable.insert(cln,scls); |
} | } |
| |
jmethodID id=env->GetMethodID(*cls,"<init>","()V"); | jmethodID id=env->GetMethodID(*cls,"<init>","()V"); |
jobject lProv=env->NewObject(*cls,id); | jobject lProv=env->NewObject(*cls,id); |
gProv=(jobject)env->NewGlobalRef(lProv); | gProv=(jobject)env->NewGlobalRef(lProv); |
if (env->ExceptionCheck()) { |
if (env->ExceptionCheck()) |
DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<cn<<PEGASUS_STD(endl)); |
{ |
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
|
"Unable to instantiate provider %s.",cn)); |
|
PEG_METHOD_EXIT(); |
return NULL; | return NULL; |
} | } |
| |
if (gProv) | if (gProv) |
{ | { |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(int)gProv<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"Inserting provider reference %p into object table.",gProv)); |
_objectTable.insert(cln,gProv); | _objectTable.insert(cln,gProv); |
} | } |
| |
|
PEG_METHOD_EXIT(); |
return gProv; | return gProv; |
} | } |
| |
|
#if 0 |
|
|
|
// Java 1.4 version of programmatically accessting the backtrace stack |
|
// NOTE: Renumber to follow current content |
|
// add to: |
|
// const char* classNames[]={ |
|
///*37*/ "java/lang/StackTraceElement" |
|
// add to: |
|
// const METHOD_STRUCT instanceMethodNames[]={ |
|
///*57 ThrowableGetStackTrace */ { /*Throwable */ |
|
///21, "getStackTrace", "()Ljava/lang/StackTraceElement;" }, |
|
///*58 StackTraceElementGetClassName */ { /*StackTraceElement*/ |
|
///37, "getClassName", "()Ljava/lang/String;" }, |
|
///*59 StackTraceElementGetFileName */ { /*StackTraceElement*/ |
|
///37, "getFileName", "()Ljava/lang/String;" }, |
|
///*60 StackTraceElementGetLineNumber */ { /*StackTraceElement*/ |
|
///37, "getLineNumber", "()I" }, |
|
///*61 StackTraceElementGetMethodName */ { /*StackTraceElement*/ |
|
///37, "getMethodName", "()Ljava/lang/String;" } |
|
|
|
String getExceptionInfo (JNIEnv *env) |
|
{ |
|
jthrowable err = env->ExceptionOccurred (); |
|
jobjectArray stackTrace = 0; |
|
String rc; |
|
|
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"getExceptionInfo"); |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"err = %ld ",(long)(jlong)err)); |
|
|
|
if (!err) |
|
{ |
|
PEG_METHOD_EXIT(); |
|
return rc; |
|
} |
|
|
|
|
|
stackTrace = (jobjectArray)env->CallObjectMethod( |
|
err, |
|
JMPIjvm::jv.ThrowableGetStackTrace); |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"stackTrace = %p ",stackTrace)); |
|
|
|
if (!stackTrace) |
|
{ |
|
PEG_METHOD_EXIT(); |
|
return rc; |
|
} |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"stackTrace length = %d",(jlong)env->GetArrayLength(stackTrace))); |
|
|
|
jobject jFirstST = 0; |
|
jstring jClass = 0; |
|
jstring jFile = 0; |
|
jstring jMethod = 0; |
|
jint jLine = 0; |
|
|
|
jFirstST = env->GetObjectArrayElement (stackTrace, 0); |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"jFirstST = %p",jFirstST)); |
|
|
|
if (!jFirstST) |
|
{ |
|
PEG_METHOD_EXIT(); |
|
return rc; |
|
} |
|
|
|
jClass = (jstring)env->CallObjectMethod( |
|
jFirstST, |
|
JMPIjvm::jv.StackTraceElementGetClassName); |
|
jFile = (jstring)env->CallObjectMethod( |
|
jFirstST, |
|
JMPIjvm::jv.StackTraceElementGetFileName); |
|
jMethod = (jstring)env->CallObjectMethod( |
|
jFirstST, |
|
JMPIjvm::jv.StackTraceElementGetMethodName); |
|
jLine = env->CallIntMethod( |
|
jFirstST, |
|
JMPIjvm::jv.StackTraceElementGetLineNumber); |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"jClass = %p, jFile = %p, jMethod = %p, jLine = %p", |
|
jClass,jFile,jMethod,jLine)); |
|
|
|
const char *pszClass = 0; |
|
const char *pszFile = 0; |
|
const char *pszMethod = 0; |
|
|
|
pszClass = env->GetStringUTFChars (jClass, NULL); |
|
pszFile = env->GetStringUTFChars (jFile, NULL); |
|
pszMethod = env->GetStringUTFChars (jMethod, NULL); |
|
|
|
std::ostringstream oss; |
|
String exceptionInfo; |
|
|
|
if (pszFile) |
|
{ |
|
oss << "File: " << pszFile; |
|
|
|
env->ReleaseStringUTFChars (jFile, pszFile); |
|
} |
|
if (jLine) |
|
{ |
|
oss << ", Line: " << jLine; |
|
} |
|
if (pszClass) |
|
{ |
|
oss << ", Class: " << pszClass; |
|
|
|
env->ReleaseStringUTFChars (jClass, pszClass); |
|
} |
|
if (pszMethod) |
|
{ |
|
oss << ", Method: " << pszMethod; |
|
|
|
env->ReleaseStringUTFChars (jMethod, pszMethod); |
|
} |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"oss = %s",(const char*)oss.str().c_str())); |
|
|
|
rc = oss.str ().c_str (); |
|
|
|
return rc; |
|
} |
|
|
|
#else |
|
|
|
String getExceptionInfo (JNIEnv *env) |
|
{ |
|
jthrowable err = env->ExceptionOccurred (); |
|
String rc; |
|
|
|
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"getExceptionInfo"); |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"err = %ld ",(long)(jlong)err)); |
|
|
|
if (!err) |
|
{ |
|
PEG_METHOD_EXIT(); |
|
return rc; |
|
} |
|
|
|
|
|
// ByteArrayOutputStream baos = new ByteArrayOutputStream (); |
|
// PrintStream ps = new PrintStream (baos); |
|
// e.printStackTrace (ps); |
|
// result = baos.toString (); |
|
|
|
jobject jBAOS = 0; |
|
jobject jPS = 0; |
|
|
|
jBAOS = env->NewObject (JMPIjvm::jv.ByteArrayOutputStreamClassRef, |
|
JMPIjvm::jv.ByteArrayOutputStreamNew); |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, "jBAOS = %p ",jBAOS)); |
|
|
|
if (!jBAOS) |
|
{ |
|
env->ExceptionDescribe (); |
|
|
|
PEG_METHOD_EXIT(); |
|
return rc; |
|
} |
|
|
|
jPS = env->NewObject (JMPIjvm::jv.PrintStreamClassRef, |
|
JMPIjvm::jv.PrintStreamNewOb, |
|
jBAOS); |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, "jPS = %p ",jPS)); |
|
|
|
if (!jPS) |
|
{ |
|
PEG_METHOD_EXIT(); |
|
return rc; |
|
} |
|
|
|
env->CallVoidMethod (err, |
|
JMPIjvm::jv.ThrowablePrintStackTrace, |
|
jPS); |
|
|
|
jstring jST = 0; |
|
|
|
jST = (jstring)env->CallObjectMethod( |
|
jBAOS, |
|
JMPIjvm::jv.ByteArrayOutputStreamToString); |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,"jST = %p ",jST)); |
|
|
|
const char *pszST = 0; |
|
|
|
pszST = env->GetStringUTFChars (jST, NULL); |
|
|
|
if (pszST) |
|
{ |
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"pszST = %s ",pszST)); |
|
|
|
rc = pszST; |
|
|
|
env->ReleaseStringUTFChars (jST, pszST); |
|
} |
|
|
|
PEG_METHOD_EXIT(); |
|
return rc; |
|
} |
|
|
|
#endif |
|
|
void JMPIjvm::checkException(JNIEnv *env) | void JMPIjvm::checkException(JNIEnv *env) |
{ | { |
if (env->ExceptionCheck()) { |
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIjvm::checkException"); |
jstring jMsg=NULL,jId=NULL; |
|
|
if (!env->ExceptionCheck ()) |
|
{ |
|
PEG_METHOD_EXIT(); |
|
return; |
|
} |
|
|
|
jstring jMsg = NULL, |
|
jId = NULL; |
int code; | int code; |
const char *cp; | const char *cp; |
String msg=String::EMPTY,id=String::EMPTY; |
String msg; |
|
String id; |
jthrowable err=env->ExceptionOccurred(); | jthrowable err=env->ExceptionOccurred(); |
DDD(env->ExceptionDescribe()); |
|
if (env->IsInstanceOf(err,JMPIjvm::jv.CIMExceptionClassRef)) { |
// PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
// "err = %ld ",(long)(jlong)err)); |
|
|
|
if (!err) |
|
{ |
|
PEG_METHOD_EXIT(); |
|
return; |
|
} |
|
|
|
PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
|
"Provider caused an exception!"); |
|
|
|
env->ExceptionDescribe (); |
|
|
|
if (env->IsInstanceOf (err, JMPIjvm::jv.CIMExceptionClassRef)) |
|
{ |
env->ExceptionClear(); | env->ExceptionClear(); |
if (err) { |
|
jMsg=(jstring)env->CallObjectMethod(err,JMPIjvm::jv.ThrowableGetMessage); |
jMsg = (jstring)env->CallObjectMethod( |
code=(int)env->CallIntMethod(err,JMPIjvm::jv.CIMExceptionGetCode); |
err, |
jId=(jstring)env->CallObjectMethod(err,JMPIjvm::jv.CIMExceptionGetID); |
JMPIjvm::jv.ThrowableGetMessage); |
if (jId) { |
code = (int)env->CallIntMethod( |
|
err, |
|
JMPIjvm::jv.CIMExceptionGetCode); |
|
jId = (jstring)env->CallObjectMethod( |
|
err, |
|
JMPIjvm::jv.CIMExceptionGetID); |
|
|
|
if (jId) |
|
{ |
cp=env->GetStringUTFChars(jId,NULL); | cp=env->GetStringUTFChars(jId,NULL); |
id=String(cp); | id=String(cp); |
env->ReleaseStringUTFChars(jId,cp); | env->ReleaseStringUTFChars(jId,cp); |
} | } |
| |
if (jMsg) { |
if (jMsg) |
|
{ |
cp=env->GetStringUTFChars(jMsg,NULL); | cp=env->GetStringUTFChars(jMsg,NULL); |
msg=String(cp); | msg=String(cp); |
env->ReleaseStringUTFChars(jMsg,cp); | env->ReleaseStringUTFChars(jMsg,cp); |
} | } |
| |
DDD(PEGASUS_STD(cerr)<<"--- throwing Pegasus exception: "<<code<<" "<<id<<" ("<<msg<<")"<<PEGASUS_STD(endl)); |
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
|
"throwing Pegasus exception: %d %s (%s)", |
|
code,(const char*)id.getCString(),(const char*)msg.getCString())); |
| |
|
PEG_METHOD_EXIT(); |
throw CIMException((CIMStatusCode)code,id+" ("+msg+")"); | throw CIMException((CIMStatusCode)code,id+" ("+msg+")"); |
} | } |
} |
else |
else { |
{ |
DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::checkException: exiting..."<<PEGASUS_STD(endl)); |
String info = getExceptionInfo (env); |
env->ExceptionDescribe(); |
|
exit(13); |
env->ExceptionClear (); |
} |
|
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1, |
|
"Java caused an exception: %s",(const char*)info.getCString())); |
|
|
|
PEG_METHOD_EXIT(); |
|
|
|
throw PEGASUS_CIM_EXCEPTION_L( |
|
CIM_ERR_FAILED, |
|
MessageLoaderParms( |
|
"ProviderManager2.JMPI.JMPIImpl.JAVA_CAUSED_EXCEPTION.STANDARD", |
|
"Java caused an exception: $0", |
|
info)); |
} | } |
} | } |
| |
|
|
| |
NULL_CHECK0(cls = (*env).FindClass("java/lang/String")); | NULL_CHECK0(cls = (*env).FindClass("java/lang/String")); |
NULL_CHECK0(mid = (*env).GetMethodID(cls, "<init>", "([B)V")); | NULL_CHECK0(mid = (*env).GetMethodID(cls, "<init>", "([B)V")); |
|
|
ary = (*env).NewByteArray((jsize)len); | ary = (*env).NewByteArray((jsize)len); |
if (ary != 0) { |
if (ary != 0) |
|
{ |
jstring str = 0; | jstring str = 0; |
(*env).SetByteArrayRegion(ary, 0, (jsize)len, |
(*env).SetByteArrayRegion (ary, |
|
0, |
|
(jsize)len, |
(jbyte *)s); | (jbyte *)s); |
if (!(*env).ExceptionOccurred()) { |
if (!(*env).ExceptionOccurred ()) |
|
{ |
str = (jstring)(*env).NewObject(cls, mid, ary); | str = (jstring)(*env).NewObject(cls, mid, ary); |
} | } |
(*env).DeleteLocalRef(ary); | (*env).DeleteLocalRef(ary); |
|
|
return str; | return str; |
} | } |
return 0; | return 0; |
} | } |
| |
|
|
/************************************************************************** | /************************************************************************** |
* name - NewPlatformStringArray | * name - NewPlatformStringArray |
* description - Returns a new array of Java string objects for the specified | * description - Returns a new array of Java string objects for the specified |
|
|
| |
NULL_CHECK0(cls = (jarray)(*env).FindClass("java/lang/String")); | NULL_CHECK0(cls = (jarray)(*env).FindClass("java/lang/String")); |
NULL_CHECK0(ary = (*env).NewObjectArray(strc, (jclass)cls, 0)); | NULL_CHECK0(ary = (*env).NewObjectArray(strc, (jclass)cls, 0)); |
for (i = 0; i < strc; i++) { |
for(i = 0; i < strc; i++) |
|
{ |
jstring str = NewPlatformString(env, *strv++); | jstring str = NewPlatformString(env, *strv++); |
|
|
NULL_CHECK0(str); | NULL_CHECK0(str); |
|
|
(*env).SetObjectArrayElement((jobjectArray)ary, i, str); | (*env).SetObjectArrayElement((jobjectArray)ary, i, str); |
(*env).DeleteLocalRef(str); | (*env).DeleteLocalRef(str); |
} | } |
|
|
return (jobjectArray)ary; | return (jobjectArray)ary; |
} | } |
| |
|
CIMPropertyList getList (JNIEnv *jEnv, jobjectArray l) |
|
{ |
CIMPropertyList getList(JNIEnv *jEnv, jobjectArray l) { |
|
CIMPropertyList pl; | CIMPropertyList pl; |
| |
if (l) { |
if (l) |
|
{ |
Array<CIMName> n; | Array<CIMName> n; |
| |
for (jsize i=0,s=jEnv->GetArrayLength(l); i<s; i++) { |
for (jsize i = 0, s = jEnv->GetArrayLength (l); i <s; i++) |
|
{ |
jstring jObj = (jstring)jEnv->GetObjectArrayElement(l,i); | jstring jObj = (jstring)jEnv->GetObjectArrayElement(l,i); |
const char *pn = jEnv->GetStringUTFChars(jObj,NULL); | const char *pn = jEnv->GetStringUTFChars(jObj,NULL); |
| |
|
|
return pl; | return pl; |
} | } |
| |
|
|
|
|
extern "C" { | extern "C" { |
| |
|
void throwCimException (JNIEnv *jEnv, CIMException &e) |
void throwCimException(JNIEnv *jEnv, CIMException & e) { |
{ |
JMPIjvm::cacheIDs(jEnv); | JMPIjvm::cacheIDs(jEnv); |
jobject ev=jEnv->NewObject(JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewI,(jint)e.getCode()); |
jobject ev = jEnv->NewObject( |
|
JMPIjvm::jv.CIMExceptionClassRef, |
|
JMPIjvm::jv.CIMExceptionNewI, |
|
(jint)e.getCode()); |
jEnv->Throw((jthrowable)ev); | jEnv->Throw((jthrowable)ev); |
} | } |
| |
void throwFailedException(JNIEnv *jEnv) { |
void throwFailedException (JNIEnv *jEnv) |
|
{ |
JMPIjvm::cacheIDs(jEnv); | JMPIjvm::cacheIDs(jEnv); |
jobject ev=jEnv->NewObject(JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewI,1); |
jobject ev = jEnv->NewObject( |
|
JMPIjvm::jv.CIMExceptionClassRef, |
|
JMPIjvm::jv.CIMExceptionNewI, |
|
1); |
jEnv->Throw((jthrowable)ev); | jEnv->Throw((jthrowable)ev); |
} | } |
| |
void throwNotSupportedException(JNIEnv *jEnv) { |
void throwNotSupportedException (JNIEnv *jEnv) |
|
{ |
JMPIjvm::cacheIDs(jEnv); | JMPIjvm::cacheIDs(jEnv); |
jobject ev=jEnv->NewObject(JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewI,7); |
jobject ev = jEnv->NewObject( |
|
JMPIjvm::jv.CIMExceptionClassRef, |
|
JMPIjvm::jv.CIMExceptionNewI, |
|
7); |
jEnv->Throw((jthrowable)ev); | jEnv->Throw((jthrowable)ev); |
} | } |
| |
| |
|
|
|
|
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
// - CIMException |
// - CIMArgument |
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1new |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1new |
(JNIEnv *jEnv, jobject jThs) { |
(JNIEnv *jEnv, jobject jThs) |
JMPIjvm::cacheIDs(jEnv); |
{ |
jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNew); |
CIMParamValue *p = new CIMParamValue (String::EMPTY,CIMValue ()); |
} |
|
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newS |
return DEBUG_ConvertCToJava (CIMParamValue*, jlong, p); |
(JNIEnv *jEnv, jobject jThs, jstring jM) { |
|
JMPIjvm::cacheIDs(jEnv); |
|
jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewSt,jM); |
|
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSO |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1newS |
(JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1) { |
(JNIEnv *jEnv, jobject jThs, jstring jN) |
JMPIjvm::cacheIDs(jEnv); |
{ |
jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewStOb,jM,jO1); |
const char *str = jEnv->GetStringUTFChars (jN, NULL); |
} |
CIMParamValue *p = new CIMParamValue (str, CIMValue ()); |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSOO |
jEnv->ReleaseStringUTFChars (jN, str); |
(JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1, jobject jO2) { |
|
JMPIjvm::cacheIDs(jEnv); |
|
jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewStObOb,jM,jO1,jO2); |
|
} |
|
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSOOO |
return DEBUG_ConvertCToJava (CIMParamValue*, jlong, p); |
(JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1, jobject jO2, jobject jO3) { |
|
JMPIjvm::cacheIDs(jEnv); |
|
jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewStObObOb,jM,jO1,jO2,jO3); |
|
} | } |
| |
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1newSV |
|
(JNIEnv *jEnv, jobject jThs, jstring jN, jlong jV) |
|
{ |
|
const char *str = jEnv->GetStringUTFChars (jN, NULL); |
|
CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV); |
|
CIMParamValue *p = 0; |
| |
|
if ( str |
// ------------------------------------- |
&& cv |
// --- |
) |
// - CIMOMHandle |
|
// --- |
|
// ------------------------------------- |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getClass |
|
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean lo, |
|
jboolean iq, jboolean ic, jobjectArray jPl) |
|
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
p = new CIMParamValue (str, *cv); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
} |
CIMPropertyList pl; |
|
OperationContext ctx; |
|
| |
if (jPl) |
jEnv->ReleaseStringUTFChars (jN, str); |
pl=getList(jEnv,jPl); |
|
else |
|
pl=CIMPropertyList(); |
|
| |
try { |
return DEBUG_ConvertCToJava (CIMParamValue*, jlong, p); |
CIMClass cls=ch->getClass(ctx,cop->getNameSpace(), |
} |
cop->getClassName(), |
|
(Boolean)lo, |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1getType |
(Boolean)iq, |
(JNIEnv *jEnv, jobject jThs, jlong jP) |
(Boolean)ic, |
{ |
pl); |
CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP); |
|
const CIMValue cv = cp->getValue (); |
|
String ref; |
|
bool fSuccess = false; |
|
int iJType = 0; |
|
_dataType *type = 0; |
| |
return DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass(cls)); |
iJType = _dataType::convertCTypeToJavaType (cv.getType (), &fSuccess); |
|
|
|
if (fSuccess) |
|
{ |
|
type = new _dataType (iJType, |
|
cv.getArraySize (), |
|
false, |
|
false, |
|
cv.isArray (), |
|
ref, |
|
true); |
} | } |
Catch(jEnv); |
|
| |
return 0; |
return DEBUG_ConvertCToJava (_dataType*, jlong, type); |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createClass |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setValue |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCl) |
(JNIEnv *jEnv, jobject jThs, jlong jP,jlong jV) |
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV); |
CIMClass *cl = DEBUG_ConvertJavaToC (jint, CIMClass*, jCl); |
|
OperationContext ctx; |
|
| |
try { |
cp->setValue (*cv); |
ch->createClass(ctx,cop->getNameSpace(),*cl); |
|
} |
|
Catch(jEnv); |
|
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setClass |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1getValue |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCl) |
(JNIEnv *jEnv, jobject jThs, jlong jP) |
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
CIMValue *cv = new CIMValue (cp->getValue ()); |
CIMClass *cl = DEBUG_ConvertJavaToC (jint, CIMClass*, jCl); |
|
OperationContext ctx; |
|
| |
try { |
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
ch->modifyClass(ctx,cop->getNameSpace(),*cl); |
|
} | } |
Catch(jEnv); |
|
|
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMArgument__1getName |
|
(JNIEnv *jEnv, jobject jThs, jlong jP) |
|
{ |
|
CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP); |
|
const String &n = cp->getParameterName (); |
|
jstring str = jEnv->NewStringUTF (n.getCString ()); |
|
|
|
return str; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteClass |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setName |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop) |
(JNIEnv *jEnv, jobject jThs, jlong jP, jstring jN) |
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
const char *str = jEnv->GetStringUTFChars (jN, NULL); |
OperationContext ctx; |
String n (str); |
| |
try { |
cp->setParameterName (n); |
ch->deleteClass(ctx,cop->getNameSpace(),cop->getClassName()); |
|
|
jEnv->ReleaseStringUTFChars (jN, str); |
} | } |
Catch(jEnv); |
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1finalize |
|
(JNIEnv *jEnv, jobject jThs, jlong jP) |
|
{ |
|
CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP); |
|
|
|
delete cp; |
|
|
|
DEBUG_ConvertCleanup (jlong, jP); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClassNames |
|
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean deep) |
// ------------------------------------- |
|
// --- |
|
// - CIMClass |
|
// --- |
|
// ------------------------------------- |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1newInstance |
|
(JNIEnv *jEnv, jobject jThs, jlong jCls) |
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
CIMNamespaceName ns = cop->getNameSpace(); |
|
OperationContext ctx; |
|
| |
try { |
if (cls) |
Array<CIMName> enm = ch->enumerateClassNames(ctx,cop->getNameSpace(),cop->getClassName(),(Boolean)deep); |
{ |
Array<CIMObjectPath> *enmop = new Array<CIMObjectPath>(); |
try |
|
{ |
|
CIMInstance *ci = new CIMInstance (cls->getClassName ()); |
|
CIMObjectPath copNew = ci->getPath (); |
| |
for (int i=0,m=enm.size(); i<m; i++) { |
copNew.setNameSpace (cls->getPath ().getNameSpace ()); |
enmop->append(CIMObjectPath(String::EMPTY,ns,enm[i])); |
ci->setPath (copNew); |
|
for (int i = 0, m = cls->getQualifierCount (); i < m; i++) |
|
{ |
|
try |
|
{ |
|
ci->addQualifier (cls->getQualifier (i).clone ()); |
|
} |
|
catch(Exception e) |
|
{ |
|
} |
} | } |
|
for (int i = 0, m = cls->getPropertyCount (); i < m; i++) |
|
{ |
|
CIMProperty cp = cls->getProperty (i); |
| |
return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, enmop); |
ci->addProperty (cp.clone ()); |
|
|
|
for (int j = 0, s = cp.getQualifierCount (); j < s; j++) |
|
{ |
|
try |
|
{ |
|
ci->getProperty (i).addQualifier (cp.getQualifier (j)); |
|
} |
|
catch (Exception e) |
|
{ |
|
} |
|
} |
|
} |
|
return DEBUG_ConvertCToJava (CIMInstance*, jlong, ci); |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
} |
| |
return 0; | return 0; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClasses |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1filterProperties |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean deep, |
(JNIEnv *jEnv, |
jboolean lo, jboolean iq, jboolean ic) |
jobject jThs, |
|
jlong jInst, |
|
jobjectArray jPl, |
|
jboolean iq, |
|
jboolean ic, |
|
jboolean lo) |
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
CIMClass *cc = DEBUG_ConvertJavaToC (jlong, CIMClass*, jInst); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
CIMClass *cf = 0; |
OperationContext ctx; |
CIMName clsn = cc->getClassName (); |
| |
try { |
if (lo) |
Array<CIMClass> en=ch->enumerateClasses(ctx, |
{ |
cop->getNameSpace(), |
cf = new CIMClass (cc->clone ()); |
cop->getClassName(), |
|
(Boolean)deep, |
CIMName clsn = cc->getClassName (); |
(Boolean)lo, |
|
(Boolean)iq, |
|
(Boolean)ic); |
|
| |
return DEBUG_ConvertCToJava (Array<CIMClass>*, jint, new Array<CIMClass>(en)); |
for (int i = cf->getPropertyCount () - 1; i>= 0; i--) |
|
{ |
|
if (cf->getProperty (i).getClassOrigin () == clsn) |
|
cf->removeProperty (i); |
} | } |
Catch(jEnv); |
|
| |
return 0; |
return DEBUG_ConvertCToJava (CIMClass*, jlong, cf); |
} | } |
|
else if (jPl) |
|
{ |
|
CIMPropertyList pl = getList (jEnv,jPl); |
|
Array<CIMName> n = pl.getPropertyNameArray (); |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getInstance |
cf = new CIMClass (clsn, cc->getSuperClassName ()); |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean lo, jboolean iq, jboolean ic, |
|
jobjectArray jPl) |
for (int i = 0, s = n.size (); i < s; i++) |
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
Uint32 pos = cc->findProperty (n[i]); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
CIMPropertyList pl; |
|
| |
if (jPl) |
if (pos != PEG_NOT_FOUND) |
pl=getList(jEnv,jPl); |
{ |
else |
if (iq) |
pl=CIMPropertyList(); |
{ |
|
CIMProperty cp = cc->getProperty (pos).clone (); |
| |
try { |
if (!ic) |
CIMInstance *inst=new CIMInstance(ch->getInstance(ctx, |
cp.setClassOrigin (CIMName ()); |
cop->getNameSpace(), |
|
*cop, |
|
(Boolean)lo, |
|
(Boolean)iq, |
|
(Boolean)ic, |
|
pl)); |
|
return DEBUG_ConvertCToJava (CIMInstance*, jint, inst); |
|
} |
|
Catch(jEnv); |
|
| |
return -1; |
cf->addProperty (cp); |
} | } |
|
else |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance |
|
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop) |
|
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
CIMProperty cp = cc->getProperty (pos); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
CIMName co; |
OperationContext ctx; |
|
| |
try { |
if (ic) |
ch->deleteInstance(ctx,cop->getNameSpace(),*cop); |
co = cp.getClassOrigin (); |
|
|
|
CIMProperty np (cp.getName (), |
|
cp.getValue (), |
|
cp.getArraySize (), |
|
cp.getReferenceClassName (), |
|
co, |
|
cp.getPropagated ()); |
|
|
|
cf->addProperty (np); |
} | } |
Catch(jEnv); |
|
} | } |
|
} |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createInstance |
if (iq) |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCi) |
|
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
for (Uint32 i = 0, s = cc->getQualifierCount (); i < s; i++) |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
{ |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi); |
cf->addQualifier (cc->getQualifier (i)); |
OperationContext ctx; |
} |
|
} |
|
} |
|
else if (iq) |
|
{ |
|
cf = new CIMClass (cc->clone ()); |
| |
try { |
if (ic) |
ci->setPath(*cop); |
return DEBUG_ConvertCToJava (CIMClass*, jlong, cf); |
| |
CIMObjectPath obj=ch->createInstance(ctx,cop->getNameSpace(),*ci); |
for (int i = cf->getPropertyCount () - 1; i >= 0; i--) |
|
{ |
|
CIMProperty cp = cf->getProperty (i); |
| |
return DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(obj)); |
cp.setClassOrigin (CIMName ()); |
|
cf->removeProperty (i); |
|
cf->addProperty (cp); |
} | } |
Catch(jEnv); |
|
|
|
return 0; |
|
} | } |
|
else |
|
{ |
|
cf = new CIMClass (clsn, cc->getSuperClassName ()); |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1modifyInstance |
for (int i = cc->getPropertyCount () - 1; i >= 0; i--) |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCi, |
|
jboolean iq, jobjectArray jPl) |
|
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
CIMProperty cp = cc->getProperty (i); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
CIMName co; |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi); |
|
CIMPropertyList pl = getList(jEnv,jPl); |
|
OperationContext ctx; |
|
| |
try { |
if (ic) |
ci->setPath(*cop); |
co = cp.getClassOrigin (); |
ch->modifyInstance(ctx,cop->getNameSpace(),*ci,(Boolean)iq,pl); |
|
|
CIMProperty np (cp.getName (), |
|
cp.getValue (), |
|
cp.getArraySize (), |
|
cp.getReferenceClassName (), |
|
co, |
|
cp.getPropagated ()); |
|
|
|
cf->addProperty (np); |
} | } |
Catch(jEnv); |
|
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstanceNames |
return DEBUG_ConvertCToJava (CIMClass*, jlong, cf); |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean deep) |
} |
|
|
|
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getName |
|
(JNIEnv *jEnv, jobject jThs, jlong jCls) |
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
| |
try { | try { |
Array<CIMObjectPath> enm=ch->enumerateInstanceNames(ctx, |
const String &cn = cls->getClassName ().getString (); |
cop->getNameSpace(), |
jstring str = jEnv->NewStringUTF (cn.getCString ()); |
cop->getClassName()); //,(Boolean)deep); |
|
return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm)); |
return str; |
} | } |
Catch(jEnv); | Catch(jEnv); |
| |
return 0; | return 0; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstances |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifier |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean deep, |
(JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jN) |
jboolean lo, jboolean iq, jboolean ic, jobjectArray jPl) |
|
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
const char *str = jEnv->GetStringUTFChars (jN, NULL); |
CIMPropertyList pl; |
jlong rv = 0; |
OperationContext ctx; |
Uint32 pos = cls->findQualifier (String (str)); |
| |
if (jPl) |
if (pos != PEG_NOT_FOUND) |
pl=getList(jEnv,jPl); |
rv = DEBUG_ConvertCToJava (CIMQualifier*, |
else |
jlong, |
pl=CIMPropertyList(); |
new CIMQualifier (cls->getQualifier (pos))); |
| |
try { |
jEnv->ReleaseStringUTFChars (jN, str); |
Array<CIMInstance> en=ch->enumerateInstances(ctx, |
|
cop->getNameSpace(), |
|
cop->getClassName(), |
|
(Boolean)deep, |
|
(Boolean)lo, |
|
(Boolean)iq, |
|
(Boolean)ic, |
|
pl); |
|
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, new Array<CIMInstance>(en)); |
|
} |
|
Catch(jEnv); |
|
| |
return 0; |
return rv; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1execQuery |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifiers |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jQuery, jstring jQl) |
(JNIEnv *jEnv, jobject jThs, jlong jCls, jobject jVec) |
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
JMPIjvm::cacheIDs (jEnv); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
const char *str = jEnv->GetStringUTFChars(jQuery,NULL); |
|
String query(str); |
|
|
|
jEnv->ReleaseStringUTFChars(jQuery,str); |
|
|
|
str=jEnv->GetStringUTFChars(jQl,NULL); |
|
|
|
String ql(str); |
|
|
|
jEnv->ReleaseStringUTFChars(jQl,str); |
|
| |
try { |
CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls); |
Array<CIMObject> enm=ch->execQuery(ctx,cop->getNameSpace(),ql,query); |
|
Array<CIMInstance> *enmInst=new Array<CIMInstance>(); |
|
| |
for (int i=0,m=enm.size(); i<m; i++) { |
for (int i = 0, s = cls->getQualifierCount (); i < s; i++) |
enmInst->append(CIMInstance(enm[i])); |
{ |
} |
CIMQualifier *cq = new CIMQualifier (cls->getQualifier (i)); |
|
jlong jCq = DEBUG_ConvertCToJava (CIMQualifier*, jlong, cq); |
|
jobject qual = jEnv->NewObject( |
|
JMPIjvm::jv.CIMQualifierClassRef, |
|
JMPIjvm::jv.CIMQualifierNewJ, |
|
jCq); |
| |
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst); |
jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,qual); |
} | } |
Catch(jEnv); |
|
| |
return 0; |
return jVec; |
} | } |
| |
|
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1hasQualifier |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getProperty |
(JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jQ) |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jN) |
|
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
const char *str = jEnv->GetStringUTFChars (jQ,NULL); |
OperationContext ctx; |
Uint32 pos = cls->findQualifier (String (str)); |
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
|
CIMName prop(str); |
|
|
|
jEnv->ReleaseStringUTFChars(jN,str); |
|
|
|
try { |
|
CIMValue *cv = new CIMValue(ch->getProperty(ctx, cop->getNameSpace(),*cop,prop)); |
|
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
jEnv->ReleaseStringUTFChars (jQ,str); |
} |
|
Catch(jEnv); |
|
| |
return -1; |
return (jboolean)(pos != PEG_NOT_FOUND); |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setProperty |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1addProperty |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jPn, jint jV) |
(JNIEnv *jEnv, jobject jThs, jlong jCls, jlong jP) |
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
CIMProperty *p = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP); |
OperationContext ctx; |
|
CIMValue *val = (CIMValue*)jCop; |
|
const char *str = jEnv->GetStringUTFChars(jPn,NULL); |
|
CIMName pName(str); |
|
|
|
jEnv->ReleaseStringUTFChars(jPn,str); |
|
| |
try { |
try |
ch->setProperty(ctx,cop->getNameSpace(),*cop,pName,*val); |
{ |
|
cls->addProperty (*p); |
} | } |
Catch(jEnv); | Catch(jEnv); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1setProperties |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jMn, jobject jIn, jobject jOut) |
(JNIEnv *jEnv, jobject jThs, jlong jCls, jobject jVec) |
{ | { |
JMPIjvm::cacheIDs(jEnv); | JMPIjvm::cacheIDs(jEnv); |
| |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
const char *str = jEnv->GetStringUTFChars(jMn,NULL); |
|
CIMName method(str); |
|
|
|
jEnv->ReleaseStringUTFChars(jMn,str); |
|
|
|
Array<CIMParamValue> in; |
|
Array<CIMParamValue> out; |
|
|
|
for (int i = 0, m = jEnv->CallIntMethod(jIn,JMPIjvm::jv.VectorSize); i < m; i++) { |
|
JMPIjvm::checkException(jEnv); |
|
|
|
jobject jProp = jEnv->CallObjectMethod(jIn,JMPIjvm::jv.VectorElementAt,i); |
|
| |
|
for (int i = cls->getPropertyCount () - 1; i >= 0; i--) |
|
{ |
|
cls->removeProperty (i); |
|
} |
|
for (Uint32 i = 0, s = jEnv->CallIntMethod( |
|
jVec, |
|
JMPIjvm::jv.VectorSize); i < s; i++) |
|
{ |
JMPIjvm::checkException(jEnv); | JMPIjvm::checkException(jEnv); |
| |
jint jp = jEnv->CallIntMethod(jProp,JMPIjvm::jv.CIMPropertyCInst); |
jobject o = jEnv->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,(i)); |
CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp); |
jlong jp = jEnv->CallLongMethod(o,JMPIjvm::jv.CIMPropertyCInst); |
|
CIMProperty *cp = DEBUG_ConvertJavaToC(jlong, CIMProperty*, jp); |
| |
JMPIjvm::checkException(jEnv); | JMPIjvm::checkException(jEnv); |
| |
in.append(CIMParamValue(p->getName().getString(),p->getValue())); |
cls->addProperty (*cp); |
|
} |
} | } |
try { |
|
CIMValue *val = new CIMValue(ch->invokeMethod(ctx,cop->getNameSpace(),*cop,method,in,out)); |
|
| |
for (int i=0,m=out.size(); i<m; i++) { |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperty |
const CIMParamValue &parm = out[i]; |
(JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jN) |
const CIMValue v = parm.getValue(); |
{ |
CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize()); |
CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls); |
jint jp = DEBUG_ConvertCToJava (CIMProperty*, jint, p); |
const char *str = jEnv->GetStringUTFChars (jN,NULL); |
jobject prop = jEnv->NewObject(JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jp); |
jlong rv = 0; |
|
Uint32 pos = cls->findProperty (CIMName (str)); |
| |
jEnv->CallVoidMethod(jOut,JMPIjvm::jv.VectorAddElement,prop); |
if (pos != PEG_NOT_FOUND) |
} |
rv = DEBUG_ConvertCToJava (CIMProperty*, |
return DEBUG_ConvertCToJava (CIMValue*, jint, val); |
jlong, |
} |
new CIMProperty (cls->getProperty (pos))); |
Catch(jEnv); |
|
| |
return 0; |
jEnv->ReleaseStringUTFChars (jN,str); |
|
|
|
return rv; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod24 |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jMn, |
(JNIEnv *jEnv, jobject jThs, jlong jCls, jobject jVec) |
jobjectArray jIn, jobjectArray jOut) |
|
{ | { |
JMPIjvm::cacheIDs(jEnv); | JMPIjvm::cacheIDs(jEnv); |
| |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
const char *str = jEnv->GetStringUTFChars(jMn,NULL); |
|
CIMName method(str); |
|
|
|
jEnv->ReleaseStringUTFChars(jMn,str); |
|
| |
Array<CIMParamValue> in; |
for (int i = 0, s = cls->getPropertyCount (); i < s; i++) |
Array<CIMParamValue> out; |
{ |
|
CIMProperty *cp = new CIMProperty (cls->getProperty (i)); |
|
jlong jCp = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp); |
|
jobject prop = jEnv->NewObject( |
|
JMPIjvm::jv.CIMPropertyClassRef, |
|
JMPIjvm::jv.CIMPropertyNewJ, |
|
jCp); |
| |
for (int i=0,m=jEnv->GetArrayLength(jIn); i<m; i++) { |
jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,prop); |
JMPIjvm::checkException(jEnv); |
} |
| |
jobject jArg=jEnv->GetObjectArrayElement(jIn,i); |
return jVec; |
JMPIjvm::checkException(jEnv); |
} |
| |
jint jp = jEnv->CallIntMethod(jArg,JMPIjvm::jv.CIMArgumentCInst); |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1new |
CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jp); |
(JNIEnv *jEnv, jobject jThs, jstring jN) |
|
{ |
|
const char *str = jEnv->GetStringUTFChars (jN,NULL); |
|
CIMClass *cls = new CIMClass (CIMName (str), CIMName ()); |
| |
JMPIjvm::checkException(jEnv); |
jEnv->ReleaseStringUTFChars (jN,str); |
| |
in.append(*p); |
return DEBUG_ConvertCToJava (CIMClass*, jlong, cls); |
} | } |
try { |
|
CIMValue *val=new CIMValue(ch->invokeMethod(ctx,cop->getNameSpace(),*cop,method,in,out)); |
|
| |
for (int i=0,m=out.size(),o=jEnv->GetArrayLength(jOut); i<m && i<o; i++) { |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getSuperClass |
CIMParamValue *parm = new CIMParamValue (out[i]); |
(JNIEnv *jEnv, jobject jThs, jlong jCls) |
jint jParm = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm); |
{ |
|
CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls); |
|
const String &cn = cls->getSuperClassName ().getString (); |
| |
jEnv->SetObjectArrayElement(jOut,i, |
jstring str = jEnv->NewStringUTF (cn.getCString ()); |
jEnv->NewObject(JMPIjvm::jv.CIMArgumentClassRef,JMPIjvm::jv.CIMArgumentNewI,jParm)); |
|
} |
|
return DEBUG_ConvertCToJava (CIMValue*, jint, val); |
|
} |
|
Catch(jEnv); |
|
| |
return 0; |
return str; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associatorNames |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getKeys |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, |
(JNIEnv *jEnv, jobject jThs, jlong jCls, jobject jVec) |
jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole) |
|
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
JMPIjvm::cacheIDs (jEnv); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); |
|
CIMName assocClass(str); |
|
| |
jEnv->ReleaseStringUTFChars(jAssocClass,str); |
CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls); |
| |
str=jEnv->GetStringUTFChars(jResultClass,NULL); |
if (cls->hasKeys ()) |
|
{ |
|
Array<CIMName> keyNames; |
| |
CIMName resultClass(str); |
cls->getKeyNames (keyNames); |
| |
jEnv->ReleaseStringUTFChars(jResultClass,str); |
for (int i = 0, s = keyNames.size (); i < s; i++) |
|
{ |
|
Uint32 pos = cls->findProperty (keyNames[i]); |
| |
str=jEnv->GetStringUTFChars(jRole,NULL); |
if (pos != PEG_NOT_FOUND) |
|
{ |
|
CIMProperty *cp = new CIMProperty (cls->getProperty (pos)); |
|
jlong jCp = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp); |
| |
String role(str); |
jobject prop = jEnv->NewObject( |
|
JMPIjvm::jv.CIMPropertyClassRef, |
|
JMPIjvm::jv.CIMPropertyNewJ, |
|
jCp); |
| |
jEnv->ReleaseStringUTFChars(jRole,str); |
jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,prop); |
|
} |
|
} |
|
} |
| |
str=jEnv->GetStringUTFChars(jResultRole,NULL); |
return jVec; |
|
} |
| |
String resultRole(str); |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethod |
|
(JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jN) |
|
{ |
|
CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls); |
|
const char *str = jEnv->GetStringUTFChars (jN,NULL); |
|
jlong rv = 0; |
|
Uint32 pos = cls->findMethod (String (str)); |
| |
jEnv->ReleaseStringUTFChars(jResultRole,str); |
if (pos != PEG_NOT_FOUND) |
|
{ |
|
rv = DEBUG_ConvertCToJava( |
|
CIMMethod*, |
|
jlong, |
|
new CIMMethod(cls->getMethod(pos))); |
|
} |
| |
try { |
jEnv->ReleaseStringUTFChars (jN,str); |
Array<CIMObjectPath> enm=ch->associatorNames(ctx, |
|
cop->getNameSpace(), |
return rv; |
*cop, |
} |
assocClass, |
|
resultClass, |
|
role, |
|
resultRole); |
|
| |
return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm)); |
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1equals |
|
(JNIEnv *jEnv, jobject jThs, jlong jCls, jlong jClsToBeCompared) |
|
{ |
|
CIMClass *cls = DEBUG_ConvertJavaToC(jlong, CIMClass*, jCls); |
|
CIMClass *clsToBeCompared = DEBUG_ConvertJavaToC( |
|
jlong, |
|
CIMClass*, |
|
jClsToBeCompared); |
|
bool fRc = false; |
|
|
|
if ( cls && clsToBeCompared ) |
|
{ |
|
try |
|
{ |
|
fRc = cls->identical (*clsToBeCompared); |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
} |
| |
return 0; |
return fRc; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associators |
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1isAssociation |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, |
(JNIEnv *jEnv, jobject jThs, jlong jCls) |
jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole, |
|
jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl) |
|
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
jboolean rv = false; |
OperationContext ctx; |
|
CIMPropertyList pl = getList(jEnv,jPl); |
|
const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); |
|
CIMName assocClass(str); |
|
| |
jEnv->ReleaseStringUTFChars(jAssocClass,str); |
if (cls) |
|
{ |
|
try |
|
{ |
|
rv = cls->isAssociation (); |
|
} |
|
Catch (jEnv); |
|
} |
| |
str=jEnv->GetStringUTFChars(jResultClass,NULL); |
return rv; |
|
} |
| |
CIMName resultClass(str); |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1findMethod |
|
(JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jName) |
|
{ |
|
CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls); |
|
jint rv = -1; |
| |
jEnv->ReleaseStringUTFChars(jResultClass,str); |
if (cls) |
|
{ |
|
const char *cstrName = jEnv->GetStringUTFChars (jName, NULL); |
| |
str=jEnv->GetStringUTFChars(jRole,NULL); |
try |
|
{ |
|
CIMName name (cstrName); |
| |
String role(str); |
rv = cls->findMethod (name); |
|
} |
|
Catch (jEnv); |
| |
jEnv->ReleaseStringUTFChars(jRole,str); |
jEnv->ReleaseStringUTFChars (jName, cstrName); |
|
} |
| |
str=jEnv->GetStringUTFChars(jResultRole,NULL); |
return rv; |
|
} |
| |
String resultRole(str); |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethodI |
|
(JNIEnv *jEnv, jobject jThs, jlong jCls, jint jMethod) |
|
{ |
|
CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls); |
|
jlong rv = 0; |
| |
jEnv->ReleaseStringUTFChars(jResultRole,str); |
if (cls && jMethod >=0) |
|
{ |
|
try |
|
{ |
|
CIMMethod cm = cls->getMethod (jMethod); |
| |
try { |
rv = DEBUG_ConvertCToJava (CIMMethod *, jlong, new CIMMethod (cm)); |
Array<CIMObject> enm = ch->associators(ctx, |
} |
cop->getNameSpace(), |
Catch (jEnv); |
*cop, |
} |
assocClass, |
|
resultClass, |
|
role, |
|
resultRole, |
|
(Boolean)includeQualifiers, |
|
(Boolean)includeClassOrigin, |
|
pl); |
|
Array<CIMInstance> *enmInst = new Array<CIMInstance>(); |
|
| |
for (int i=0,m=enm.size(); i<m; i++) { |
return rv; |
enmInst->append(CIMInstance(enm[i])); |
|
} | } |
| |
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst); |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethodCount |
|
(JNIEnv *jEnv, jobject jThs, jlong jCls) |
|
{ |
|
CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls); |
|
jint rv = 0; |
|
|
|
if (cls) |
|
{ |
|
try |
|
{ |
|
rv = cls->getMethodCount (); |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
} |
| |
return 0; |
return rv; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1referenceNames |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1finalize |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, |
(JNIEnv *jEnv, jobject jThs, jlong jCls) |
jstring jAssocClass, jstring jRole) |
|
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); |
|
CIMName assocClass(str); |
|
| |
jEnv->ReleaseStringUTFChars(jAssocClass,str); |
delete cls; |
| |
str=jEnv->GetStringUTFChars(jRole,NULL); |
DEBUG_ConvertCleanup (jlong, jCls); |
|
} |
| |
String role(str); |
|
| |
jEnv->ReleaseStringUTFChars(jRole,str); |
// ------------------------------------- |
|
// --- |
|
// - CIMClient |
|
// --- |
|
// ------------------------------------- |
| |
try { |
void checkNs (CIMObjectPath *cop, jlong jNs) |
Array<CIMObjectPath> enm = ch->referenceNames(ctx, |
{ |
cop->getNameSpace(), |
if (cop->getNameSpace ().isNull ()) |
*cop, |
{ |
assocClass, |
_nameSpace *cNs = DEBUG_ConvertJavaToC (jlong, _nameSpace*, jNs); |
role); |
|
| |
return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm)); |
cop->setNameSpace (CIMNamespaceName (cNs->nameSpace ())); |
} | } |
Catch(jEnv); |
|
|
|
return 0; |
|
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1references |
static int normalizeNs (String &ns, String &nsBase, String &lastNsComp) |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, |
|
jstring jAssocClass, jstring jRole, |
|
jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl) |
|
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
Uint32 n = ns.size (); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
CIMPropertyList pl = getList(jEnv,jPl); |
|
const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); |
|
CIMName assocClass(str); |
|
|
|
jEnv->ReleaseStringUTFChars(jAssocClass,str); |
|
|
|
str=jEnv->GetStringUTFChars(jRole,NULL); |
|
|
|
String role(str); |
|
| |
jEnv->ReleaseStringUTFChars(jRole,str); |
if (ns[n-1] == '/') |
|
{ |
|
if (n >= 2) |
|
ns = ns.subString (0, n-2); |
|
} |
| |
try { |
lastNsComp = ns; |
Array<CIMObject> enm = ch->references(ctx, |
nsBase = "root"; |
cop->getNameSpace(), |
|
*cop, |
|
assocClass, |
|
role, |
|
(Boolean)includeQualifiers, |
|
(Boolean)includeClassOrigin, |
|
pl); |
|
Array<CIMInstance> *enmInst = new Array<CIMInstance>(); |
|
| |
for (int i=0,m=enm.size(); i<m; i++) { |
n = ns.reverseFind ('/'); |
enmInst->append(CIMInstance(enm[i])); |
|
} |
|
| |
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst); |
if (n != PEG_NOT_FOUND) |
|
{ |
|
lastNsComp = ns.subString (n+1); |
|
nsBase = ns.subString (0, n); |
} | } |
Catch(jEnv); |
|
| |
return 0; | return 0; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent |
Boolean verifyServerCertificate (SSLCertificateInfo &certInfo) |
(JNIEnv *jEnv, jobject jThs, jint jCh, jstring jName, jstring jNs, jint jInd) |
|
{ | { |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
// |
CIMInstance *ind = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInd); |
// If server certificate was found in CA trust store and validated, then |
const char *str = jEnv->GetStringUTFChars (jName, NULL); |
// return 'true' to accept the certificate, otherwise return 'false'. |
String name (str); |
// |
|
if (certInfo.getResponseCode () == 1) |
jEnv->ReleaseStringUTFChars (jName, str); |
|
|
|
str = jEnv->GetStringUTFChars (jNs, NULL); |
|
|
|
String ns (str); |
|
|
|
jEnv->ReleaseStringUTFChars (jNs, str); |
|
|
|
CIMObjectPath ref (ind->getPath ()); |
|
|
|
ref.setNameSpace (ns); |
|
DDD(PEGASUS_STD(cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent() ref = "<<ref.toString ()<<PEGASUS_STD(endl)); |
|
DDD(PEGASUS_STD(cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent() ind = "<<ind->getPath ().toString ()<<PEGASUS_STD(endl)); |
|
ind->setPath (ref); |
|
DDD(PEGASUS_STD(cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent() ind = "<<ind->getPath ().toString ()<<PEGASUS_STD(endl)); |
|
|
|
JMPIProviderManager::indProvRecord *prec = NULL; |
|
String sPathString = ind->getPath ().toString (); |
|
OperationContext *context = NULL; |
|
bool fResult = false; |
|
|
|
{ | { |
AutoMutex lock (JMPIProviderManager::mutexProvTab); |
return true; |
|
} |
fResult = JMPIProviderManager::provTab.lookup (name, prec); |
else |
|
{ |
DDD(PEGASUS_STD(cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent() fResult = "<<fResult<<", name = "<<name<<PEGASUS_STD(endl)); |
return false; |
|
} |
} | } |
| |
if (fResult) |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1newNaUnPw |
|
(JNIEnv *jEnv, jobject jThs, jlong jNs, jstring jUn, jstring jPw) |
{ | { |
if (prec->enabled) |
_nameSpace *cNs = DEBUG_ConvertJavaToC (jlong, _nameSpace*, jNs); |
|
const char *un = jEnv->GetStringUTFChars (jUn, NULL); |
|
const char *pw = jEnv->GetStringUTFChars (jPw, NULL); |
|
jlong jCc = 0; |
|
|
|
SSLContext *sslContext = 0; // initialized for unencrypted connection |
|
|
|
#ifdef PEGASUS_HAS_SSL |
|
if (cNs->isHttps ()) |
{ | { |
try | try |
{ | { |
prec->handler->deliver (*prec->ctx, *ind); |
sslContext = new SSLContext (PEGASUS_SSLCLIENT_CERTIFICATEFILE, |
|
verifyServerCertificate, |
|
PEGASUS_SSLCLIENT_RANDOMFILE); |
} | } |
Catch(jEnv); |
catch (Exception &e) |
|
{ |
|
cerr << "JMPI: Error: could not create SSLContext: " |
|
<< e.getMessage() << endl; |
|
return jCc; |
} | } |
} | } |
|
#endif |
|
|
|
try { |
|
CIMClient *cc = new CIMClient (); |
|
|
|
if (sslContext) |
|
{ |
|
cc->connect (cNs->hostName (), cNs->port (), *sslContext, un, pw); |
|
} |
else | else |
{ | { |
DDD(PEGASUS_STD(cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent() provider name \""<<name<<"\" not found"<<PEGASUS_STD(endl)); |
cc->connect (cNs->hostName (), cNs->port (), un, pw); |
} | } |
|
|
|
jCc = DEBUG_ConvertCToJava (CIMClient*, jlong, cc); |
} | } |
|
Catch (jEnv); |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1finalize |
jEnv->ReleaseStringUTFChars (jUn, un); |
(JNIEnv *jEnv, jobject jThs, jint jCh) |
jEnv->ReleaseStringUTFChars (jPw, pw); |
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
|
| |
delete ch; |
delete sslContext; |
| |
DEBUG_ConvertCleanup (jint, jCh); |
return jCc; |
} | } |
| |
// ------------------------------------- |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1disconnect |
// --- |
(JNIEnv *jEnv, jobject jThs, jlong jCc) |
// - CIMClass |
|
// --- |
|
// ------------------------------------- |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1newInstance |
|
(JNIEnv *jEnv, jobject jThs, jint jCls) |
|
{ | { |
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
|
try { |
|
CIMInstance *ci = new CIMInstance(cls->getClassName()); |
|
| |
for (int i=0,m=cls->getQualifierCount(); i<m; i++) { |
|
try { | try { |
ci->addQualifier(cls->getQualifier(i).clone()); |
cCc->disconnect (); |
} | } |
catch (Exception e) {} |
Catch (jEnv); |
} | } |
for (int i=0,m=cls->getPropertyCount(); i<m; i++) { |
|
CIMProperty cp = cls->getProperty(i); |
|
| |
ci->addProperty(cp.clone()); |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1getClass |
|
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jboolean lo, |
|
jboolean iq, jboolean ic, jobjectArray jPl) |
|
{ |
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
CIMPropertyList pl = getList (jEnv, jPl); |
| |
for (int j=0, s=cp.getQualifierCount(); j<s; j++) { |
if ( cCc |
|
&& cop |
|
) |
|
{ |
try { | try { |
ci->getProperty(i).addQualifier(cp.getQualifier(j)); |
checkNs (cop, jNs); |
} |
|
catch (Exception e) {} |
|
} |
|
} |
|
| |
return DEBUG_ConvertCToJava (CIMInstance*, jint, ci); |
CIMClass cls = cCc->getClass (cop->getNameSpace (), |
|
cop->getClassName (), |
|
(Boolean)lo, |
|
(Boolean)iq, |
|
(Boolean)ic, |
|
pl); |
|
CIMObjectPath copNew = cls.getPath (); |
|
|
|
copNew.setNameSpace (cop->getNameSpace ()); |
|
cls.setPath (copNew); |
|
|
|
return DEBUG_ConvertCToJava (CIMClass*, jlong, new CIMClass (cls)); |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
} |
| |
return 0; | return 0; |
} | } |
| |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getName |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteClass |
(JNIEnv *jEnv, jobject jThs, jint jCls) |
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop) |
{ | { |
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
| |
try { | try { |
const String &cn=cls->getClassName().getString(); |
checkNs (cop, jNs); |
jstring str=jEnv->NewStringUTF(cn.getCString()); |
|
| |
return str; |
cCc->deleteClass (cop->getNameSpace (), |
|
cop->getClassName ()); |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
|
return 0; |
|
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifier |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createClass |
(JNIEnv *jEnv, jobject jThs, jint jCls, jstring jN) |
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jlong jCl) |
{ | { |
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
jint rv = -1; |
CIMClass *cl = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCl); |
Uint32 pos = cls->findQualifier(String(str)); |
|
|
|
if (pos!=PEG_NOT_FOUND) |
|
rv = DEBUG_ConvertCToJava (CIMQualifier*, jint, new CIMQualifier(cls->getQualifier(pos))); |
|
|
|
jEnv->ReleaseStringUTFChars(jN,str); |
|
| |
return rv; |
try { |
|
cCc->createClass (cop->getNameSpace (), *cl); |
} | } |
|
Catch (jEnv); |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperty |
|
(JNIEnv *jEnv, jobject jThs, jint jCls, jstring jN) |
|
{ |
|
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
|
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
|
jint rv = -1; |
|
Uint32 pos = cls->findProperty(CIMName(str)); |
|
|
|
if (pos!=PEG_NOT_FOUND) |
|
rv = DEBUG_ConvertCToJava (CIMProperty*, jint, new CIMProperty(cls->getProperty(pos))); |
|
|
|
jEnv->ReleaseStringUTFChars(jN,str); |
|
|
|
return rv; |
|
} | } |
| |
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1hasQualifier |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setClass |
(JNIEnv *jEnv, jobject jThs, jint jCls, jstring jQ) |
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jlong jCl) |
{ | { |
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
const char *str = jEnv->GetStringUTFChars(jQ,NULL); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
Uint32 pos = cls->findQualifier(String(str)); |
CIMClass *cl = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCl); |
| |
jEnv->ReleaseStringUTFChars(jQ,str); |
try { |
|
checkNs (cop, jNs); |
| |
return (jboolean)(pos!=PEG_NOT_FOUND); |
cCc->modifyClass (cop->getNameSpace (), *cl); |
|
} |
|
Catch (jEnv); |
} | } |
| |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1getInstance |
(JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) |
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jboolean lo, |
|
jboolean iq, jboolean ic, jobjectArray jPl) |
{ | { |
JMPIjvm::cacheIDs(jEnv); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
CIMPropertyList pl = getList (jEnv, jPl); |
| |
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
try { |
|
checkNs (cop, jNs); |
| |
for (int i=0,s=cls->getPropertyCount(); i<s; i++) { |
CIMInstance inst = cCc->getInstance (cop->getNameSpace (), |
CIMProperty *cp = new CIMProperty(cls->getProperty(i)); |
*cop, |
jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); |
(Boolean)lo, |
|
(Boolean)iq, |
|
(Boolean)ic, |
|
pl); |
| |
jobject prop=jEnv->NewObject(JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jCp); |
inst.setPath (*cop); |
| |
jEnv->CallVoidMethod(jVec,JMPIjvm::jv.VectorAddElement,prop); |
return DEBUG_ConvertCToJava (CIMInstance*, jlong, new CIMInstance (inst)); |
} | } |
|
Catch (jEnv); |
| |
return jVec; |
return 0; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1addProperty |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteInstance |
(JNIEnv *jEnv, jobject jThs, jint jCls, jint jP) |
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop) |
{ | { |
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
| |
cls->addProperty(*p); |
try { |
|
checkNs (cop, jNs); |
|
|
|
cCc->deleteInstance (cop->getNameSpace (), *cop); |
|
} |
|
Catch (jEnv); |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1setProperties |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1createInstance |
(JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) |
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jlong jCi) |
{ | { |
JMPIjvm::cacheIDs(jEnv); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jCi); |
|
|
|
try { |
|
checkNs (cop, jNs); |
| |
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
ci->setPath (*cop); |
| |
for (int i=cls->getPropertyCount()-1; i>=0; i--) { |
CIMObjectPath obj = cCc->createInstance (cop->getNameSpace (), *ci); |
cls->removeProperty(i); |
|
|
return DEBUG_ConvertCToJava(CIMObjectPath*,jlong,new CIMObjectPath (obj)); |
} | } |
for (Uint32 i=0,s=jEnv->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<s; i++) { |
Catch (jEnv); |
JMPIjvm::checkException(jEnv); |
|
| |
jobject o=jEnv->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,(i)); |
return 0; |
|
} |
| |
jint jp = jEnv->CallIntMethod(o,JMPIjvm::jv.CIMPropertyCInst); |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1modifyInstance |
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp); |
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jlong jCi, |
|
jboolean iq, jobjectArray jPl) |
|
{ |
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jCi); |
|
CIMPropertyList pl = getList (jEnv, jPl); |
| |
JMPIjvm::checkException(jEnv); |
try { |
|
checkNs (cop, jNs); |
| |
cls->addProperty(*cp); |
ci->setPath (*cop); |
|
|
|
cCc->modifyInstance (cop->getNameSpace (), *ci, (Boolean)iq, pl); |
} | } |
|
Catch (jEnv); |
} | } |
| |
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClasses( |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifiers |
JNIEnv *jEnv, |
(JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) |
jobject jThs, |
|
jlong jCc, |
|
jlong jNs, |
|
jlong jCop, |
|
jboolean deep, |
|
jboolean lo, |
|
jboolean iq, |
|
jboolean ic) |
{ | { |
JMPIjvm::cacheIDs(jEnv); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
| |
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
try { |
|
checkNs (cop, jNs); |
| |
for (int i=0,s=cls->getQualifierCount(); i<s; i++) { |
Array<CIMClass> enm = cCc->enumerateClasses (cop->getNameSpace (), |
CIMQualifier *cq = new CIMQualifier(cls->getQualifier(i)); |
cop->getClassName (), |
jint jCq = DEBUG_ConvertCToJava (CIMQualifier*, jint, cq); |
(Boolean)deep, |
jobject qual = jEnv->NewObject(JMPIjvm::jv.CIMQualifierClassRef,JMPIjvm::jv.CIMQualifierNewI,jCq); |
(Boolean)lo, |
|
(Boolean)iq, |
|
(Boolean)ic); |
| |
jEnv->CallVoidMethod(jVec,JMPIjvm::jv.VectorAddElement,qual); |
return DEBUG_ConvertCToJava( |
|
Array<CIMClass>*, |
|
jlong, |
|
new Array<CIMClass> (enm)); |
} | } |
|
Catch (jEnv); |
| |
return jVec; |
return 0; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1new |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClassNames |
(JNIEnv *jEnv, jobject jThs, jstring jN) |
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jboolean deep) |
{ | { |
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
CIMClass *cls = new CIMClass(CIMName(str), CIMName()); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
CIMNamespaceName ns = cop->getNameSpace (); |
| |
jEnv->ReleaseStringUTFChars(jN,str); |
try { |
|
checkNs (cop, jNs); |
| |
return DEBUG_ConvertCToJava (CIMClass*, jint, cls); |
Array<CIMName> enm = cCc->enumerateClassNames(ns, |
} |
cop->getClassName(), |
|
(Boolean)deep); |
|
Array<CIMObjectPath> *enmop = new Array<CIMObjectPath> (); |
| |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getSuperClass |
for (int i = 0, m = enm.size (); i < m; i++) |
(JNIEnv *jEnv, jobject jThs, jint jCls) |
|
{ | { |
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
enmop->append (CIMObjectPath (String::EMPTY, ns, enm[i])); |
const String &cn = cls->getSuperClassName().getString(); |
} |
| |
jstring str=jEnv->NewStringUTF(cn.getCString()); |
return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jlong, enmop); |
|
} |
|
Catch (jEnv); |
| |
return str; |
return 0; |
} | } |
| |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getKeys |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstanceNames |
(JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) |
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jboolean deep) |
{ | { |
JMPIjvm::cacheIDs(jEnv); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
| |
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
try { |
|
checkNs (cop,jNs); |
if (cls->hasKeys()) { |
|
Array<CIMName> keyNames; |
|
cls->getKeyNames(keyNames); |
|
for(int i=0, s=keyNames.size();i<s;i++){ |
|
Uint32 pos=cls->findProperty(keyNames[i]); |
|
if (pos!=PEG_NOT_FOUND){ |
|
CIMProperty *cp = new CIMProperty(cls->getProperty(pos)); |
|
jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); |
|
| |
jobject prop=jEnv->NewObject(JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jCp); |
Array<CIMObjectPath> enm = cCc->enumerateInstanceNames( |
|
cop->getNameSpace(), |
|
cop->getClassName ()); //, (Boolean)deep); |
| |
jEnv->CallVoidMethod(jVec,JMPIjvm::jv.VectorAddElement,prop); |
return DEBUG_ConvertCToJava( |
} |
Array<CIMObjectPath>*, |
} |
jlong, |
|
new Array<CIMObjectPath> (enm)); |
} | } |
|
Catch (jEnv); |
| |
return jVec; |
return 0; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethod |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstances( |
(JNIEnv *jEnv, jobject jThs, jint jCls, jstring jN) |
JNIEnv *jEnv, |
|
jobject jThs, |
|
jlong jCc, |
|
jlong jNs, |
|
jlong jCop, |
|
jboolean deep, |
|
jboolean lo, |
|
jboolean iq, |
|
jboolean ic, |
|
jobjectArray jPl) |
{ | { |
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
jint rv = -1; |
CIMPropertyList pl = getList (jEnv,jPl); |
Uint32 pos = cls->findMethod(String(str)); |
|
|
|
if (pos!=PEG_NOT_FOUND) { |
|
rv = DEBUG_ConvertCToJava (CIMMethod*, jint, new CIMMethod(cls->getMethod(pos))); |
|
} |
|
|
|
jEnv->ReleaseStringUTFChars(jN,str); |
|
| |
return rv; |
try { |
} |
checkNs (cop, jNs); |
| |
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1equals |
CIMPropertyList props; |
(JNIEnv *jEnv, jobject jThs, jint jCls, jint jClsToBeCompared) |
Array<CIMInstance> enm = cCc->enumerateInstances (cop->getNameSpace (), |
{ |
cop->getClassName (), |
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
(Boolean)deep, |
CIMClass *clsToBeCompared = DEBUG_ConvertJavaToC (jint, CIMClass*, jClsToBeCompared); |
(Boolean)lo, |
|
(Boolean)iq, |
|
(Boolean)ic,pl); |
| |
return cls->identical(*clsToBeCompared); |
return DEBUG_ConvertCToJava( |
|
Array<CIMInstance>*, |
|
jlong, |
|
new Array<CIMInstance> (enm)); |
} | } |
|
Catch (jEnv); |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1finalize |
return 0; |
(JNIEnv *jEnv, jobject jThs, jint jCls) |
|
{ |
|
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
|
|
|
delete cls; |
|
|
|
DEBUG_ConvertCleanup (jint, jCls); |
|
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1filterProperties |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateQualifiers |
(JNIEnv *jEnv, jobject jThs, jint jInst, jobjectArray jPl, jboolean iq, jboolean ic, jboolean lo) |
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop) |
{ | { |
CIMClass *cc = DEBUG_ConvertJavaToC (jint, CIMClass*, jInst); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
CIMClass *cf = 0; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
CIMName clsn = cc->getClassName(); |
|
| |
if (lo) { |
try { |
cf = new CIMClass(cc->clone()); |
checkNs (cop, jNs); |
| |
CIMName clsn=cc->getClassName(); |
Array<CIMQualifierDecl> enm=cCc->enumerateQualifiers(cop->getNameSpace()); |
| |
for (int i=cf->getPropertyCount()-1; i>=0; i--) |
return DEBUG_ConvertCToJava( |
if (cf->getProperty(i).getClassOrigin()==clsn) cf->removeProperty(i); |
Array<CIMQualifierDecl>*, |
|
jlong, |
|
new Array<CIMQualifierDecl> (enm)); |
|
} |
|
Catch (jEnv); |
| |
return DEBUG_ConvertCToJava (CIMClass*, jint, cf); |
return 0; |
} | } |
else if (jPl) { |
|
CIMPropertyList pl = getList(jEnv,jPl); |
|
Array<CIMName> n = pl.getPropertyNameArray(); |
|
| |
cf = new CIMClass(clsn, cc->getSuperClassName()); |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1getQualifier |
|
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop) |
|
{ |
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
| |
for (int i = 0,s = n.size(); i < s; i++) { |
try { |
Uint32 pos=cc->findProperty(n[i]); |
checkNs (cop,jNs); |
| |
if (pos!=PEG_NOT_FOUND) { |
CIMQualifierDecl *val = new CIMQualifierDecl( |
if (iq) { |
cCc->getQualifier( |
CIMProperty cp = cc->getProperty(pos).clone(); |
cop->getNameSpace (), |
|
cop->getClassName ())); |
| |
if (!ic) |
return DEBUG_ConvertCToJava (CIMQualifierDecl*, jlong, val); |
cp.setClassOrigin(CIMName()); |
} |
|
Catch (jEnv); |
| |
cf->addProperty(cp); |
return 0; |
} | } |
else { |
|
CIMProperty cp = cc->getProperty(pos); |
|
CIMName co; |
|
| |
if (ic) |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setQualifier |
co = cp.getClassOrigin(); |
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jlong jQ) |
|
{ |
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jlong, CIMQualifierDecl*, jQ); |
| |
CIMProperty np(cp.getName(), |
try { |
cp.getValue(), |
checkNs (cop, jNs); |
cp.getArraySize(), |
|
cp.getReferenceClassName(), |
|
co, |
|
cp.getPropagated()); |
|
| |
cf->addProperty(np); |
cCc->setQualifier (cop->getNameSpace (), *qt); |
} |
|
} |
|
} | } |
if (iq) |
Catch (jEnv); |
for (Uint32 i = 0, s = cc->getQualifierCount(); i < s; i++) |
|
cf->addQualifier(cc->getQualifier(i)); |
|
} | } |
else if (iq) { |
|
cf = new CIMClass(cc->clone()); |
|
| |
if (ic) |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteQualifier |
return DEBUG_ConvertCToJava (CIMClass*, jint, cf); |
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop) |
|
{ |
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
| |
for (int i = cf->getPropertyCount()-1; i >= 0; i--) { |
try { |
CIMProperty cp=cf->getProperty(i); |
checkNs (cop, jNs); |
| |
cp.setClassOrigin(CIMName()); |
cCc->deleteQualifier (cop->getNameSpace (), cop->getClassName ()); |
cf->removeProperty(i); |
|
cf->addProperty(cp); |
|
} | } |
|
Catch (jEnv); |
} | } |
else { |
|
cf = new CIMClass(clsn, cc->getSuperClassName()); |
|
| |
for (int i = cc->getPropertyCount()-1; i >= 0; i--) { |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty |
CIMProperty cp = cc->getProperty(i); |
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jstring jPn) |
CIMName co; |
{ |
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
const char *str = jEnv->GetStringUTFChars (jPn, NULL); |
|
CIMName pName (str); |
|
jlong jCv = 0; |
| |
if (ic) |
try { |
co = cp.getClassOrigin(); |
checkNs (cop, jNs); |
| |
CIMProperty np(cp.getName(), |
CIMValue *val = new CIMValue(cCc->getProperty( |
cp.getValue(), |
cop->getNameSpace(), |
cp.getArraySize(), |
*cop, |
cp.getReferenceClassName(), |
pName)); |
co, |
|
cp.getPropagated()); |
|
| |
cf->addProperty(np); |
jCv = DEBUG_ConvertCToJava (CIMValue*, jlong, val); |
} |
|
} | } |
|
Catch (jEnv); |
| |
return DEBUG_ConvertCToJava (CIMClass*, jint, cf); |
jEnv->ReleaseStringUTFChars (jPn, str); |
} |
|
| |
|
return jCv; |
|
} |
| |
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty( |
|
JNIEnv *jEnv, |
|
jobject jThs, |
|
jlong jCc, |
|
jlong jNs, |
|
jlong jCop, |
|
jstring jPn, |
|
jlong jV) |
|
{ |
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
CIMValue *val = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV); |
|
const char *str = jEnv->GetStringUTFChars (jPn, NULL); |
|
CIMName pName (str); |
| |
// ------------------------------------- |
try { |
// --- |
checkNs (cop,jNs); |
// - CIMInstance |
|
// --- |
|
| |
// ------------------------------------- |
cCc->setProperty (cop->getNameSpace (), *cop, pName, *val); |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1new |
|
(JNIEnv *jEnv, jobject jThs) |
|
{ |
|
return DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance()); |
|
} | } |
|
Catch (jEnv); |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1newCn |
jEnv->ReleaseStringUTFChars (jPn, str); |
(JNIEnv *jEnv, jobject jThs, jstring jN) |
|
{ |
|
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
|
CIMInstance *ci = new CIMInstance(CIMName(str)); |
|
|
|
jEnv->ReleaseStringUTFChars(jN,str); |
|
|
|
return DEBUG_ConvertCToJava (CIMInstance*, jint, ci); |
|
} | } |
| |
//Added by Andy Viciu |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery( |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setName |
JNIEnv *jEnv, |
(JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN) |
jobject jThs, |
|
jlong jCc, |
|
jlong jNs, |
|
jlong jCop, |
|
jstring jQuery, |
|
jstring jQl) |
{ | { |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
const char *str = jEnv->GetStringUTFChars (jQuery, NULL); |
|
String query (str); |
| |
jEnv->ReleaseStringUTFChars(jN,str); |
jEnv->ReleaseStringUTFChars (jQuery, str); |
| |
/* NOT SUPPORTED AND NOT NEEDED*/ |
str = jEnv->GetStringUTFChars (jQl, NULL); |
} |
|
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperty |
String ql (str); |
(JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN, jint jV) |
|
{ |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); |
|
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); |
|
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
|
Uint32 pos = ci->findProperty(CIMName(str)); |
|
| |
try { |
jEnv->ReleaseStringUTFChars (jQl, str); |
if (pos!=PEG_NOT_FOUND) |
|
{ |
|
CIMProperty cp=ci->getProperty(pos); |
|
| |
if (cp.getType()==cv->getType()) |
try { |
{ |
checkNs (cop, jNs); |
cp.setValue(*cv); |
|
} |
|
else |
|
{ |
|
DDD(PEGASUS_STD(cerr)<<"!!! CIMInstance.setProperty - Wrong type of CIMValue (instance name:"<<ci->getClassName().getString()<<", property name: "<<str<<")"); |
|
DDD(PEGASUS_STD(cerr)<<"!!! CIMInstance.setProperty : "<<cp.getType()<<" <> "<<cv->getType()<<PEGASUS_STD(endl)); |
|
| |
throw CIMException(CIM_ERR_FAILED, String("Type mismatch")); |
Array<CIMObject> enm = cCc->execQuery (cop->getNameSpace (), |
} |
ql, |
|
query); |
|
Array<CIMInstance> *enmInst = new Array<CIMInstance> (); |
| |
ci->removeProperty(pos); |
for (int i = 0,m = enm.size (); i<m; i++) |
ci->addProperty(cp); |
|
} |
|
else |
|
{ | { |
CIMProperty *cp=new CIMProperty(CIMName(str),*cv); |
enmInst->append (CIMInstance (enm[i])); |
ci->addProperty(*cp); |
|
} | } |
|
|
|
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jlong, enmInst); |
} | } |
Catch(jEnv); | Catch(jEnv); |
| |
jEnv->ReleaseStringUTFChars(jN,str); |
return 0; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperties |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod( |
(JNIEnv *jEnv, jobject jThs, jint jInst, jobject jV) |
JNIEnv *jEnv, |
|
jobject jThs, |
|
jlong jCc, |
|
jlong jNs, |
|
jlong jCop, |
|
jstring jMn, |
|
jobject jIn, |
|
jobject jOut) |
{ | { |
throw CIMException(CIM_ERR_NOT_SUPPORTED, String("Not yet supported")); |
JMPIjvm::cacheIDs (jEnv); |
} |
|
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperty |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
(JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN) |
CIMObjectPath *cop = DEBUG_ConvertJavaToC(jlong, CIMObjectPath*, jCop); |
|
const char *str = jEnv->GetStringUTFChars (jMn, NULL); |
|
CIMName method (str); |
|
jlong jCv = 0; |
|
Array<CIMParamValue> in; |
|
Array<CIMParamValue> out; |
|
|
|
for (int i = 0,m = jEnv->CallIntMethod(jIn,JMPIjvm::jv.VectorSize); i<m; i++) |
{ | { |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); |
JMPIjvm::checkException (jEnv); |
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
|
jint rv = -1; |
jobject jProp=jEnv->CallObjectMethod(jIn,JMPIjvm::jv.VectorElementAt,i); |
|
|
|
JMPIjvm::checkException (jEnv); |
|
|
|
jlong jp = jEnv->CallLongMethod(jProp,JMPIjvm::jv.CIMPropertyCInst); |
|
CIMProperty *p = DEBUG_ConvertJavaToC(jlong, CIMProperty*, jp); |
|
|
|
JMPIjvm::checkException (jEnv); |
|
|
|
in.append (CIMParamValue (p->getName ().getString (),p->getValue ())); |
|
} |
| |
try { | try { |
Uint32 pos = ci->findProperty(CIMName(str)); |
checkNs (cop, jNs); |
| |
if (pos != PEG_NOT_FOUND) |
CIMValue *val = new CIMValue( |
|
cCc->invokeMethod( |
|
cop->getNameSpace(), |
|
*cop, |
|
method, |
|
in, |
|
out)); |
|
|
|
for (int i = 0,m = out.size (); i<m; i++) |
{ | { |
CIMProperty *cp = new CIMProperty(ci->getProperty(pos)); |
const CIMParamValue &parm = out[i]; |
|
const CIMValue v = parm.getValue (); |
|
CIMProperty *p = new CIMProperty( |
|
parm.getParameterName(), |
|
v, |
|
v.getArraySize()); |
|
jlong jp = DEBUG_ConvertCToJava (CIMProperty*, jlong, p); |
|
jobject prop = jEnv->NewObject( |
|
JMPIjvm::jv.CIMPropertyClassRef, |
|
JMPIjvm::jv.CIMPropertyNewJ, |
|
jp); |
| |
rv = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); |
jEnv->CallVoidMethod (jOut,JMPIjvm::jv.VectorAddElement,prop); |
} | } |
|
|
|
jCv = DEBUG_ConvertCToJava (CIMValue*, jlong, val); |
} | } |
Catch(jEnv); | Catch(jEnv); |
| |
jEnv->ReleaseStringUTFChars(jN,str); |
jEnv->ReleaseStringUTFChars (jMn,str); |
| |
return rv; |
return jCv; |
} | } |
| |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getKeyValuePairs |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod24 |
(JNIEnv *jEnv, jobject jThs, jint jInst, jobject jVec) |
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jstring jMn, |
|
jobjectArray jIn, jobjectArray jOut) |
{ | { |
JMPIjvm::cacheIDs(jEnv); | JMPIjvm::cacheIDs(jEnv); |
| |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
const char *str = jEnv->GetStringUTFChars (jMn, NULL); |
|
CIMName method (str); |
|
jlong jCv = 0; |
|
Array<CIMParamValue> in; |
|
Array<CIMParamValue> out; |
| |
//@HACK |
if (jIn) |
//cout << "ci->getPropertyCount() = " << ci->getPropertyCount() << endl; |
{ |
for (int i=0,s=ci->getPropertyCount(); i<s; i++) { |
for (int i = 0, m = jEnv->GetArrayLength (jIn); i < m; i++) |
//cout << ci->getProperty(i).getName ().getString () |
{ |
// << " " |
JMPIjvm::checkException (jEnv); |
// << ci->getProperty(i).getQualifierCount () |
|
// << " " |
|
// << ci->getProperty(i).findQualifier(CIMName ("key")) |
|
// << endl; |
|
if (ci->getProperty(i).findQualifier(String("key"))!=PEG_NOT_FOUND) { |
|
CIMProperty *cp = new CIMProperty(ci->getProperty(i)); |
|
jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); |
|
| |
jobject prop=jEnv->NewObject(JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jCp); |
jobject jArg = jEnv->GetObjectArrayElement (jIn, i); |
| |
jEnv->CallVoidMethod(jVec,JMPIjvm::jv.VectorAddElement,prop); |
JMPIjvm::checkException (jEnv); |
} |
|
} |
|
| |
return jVec; |
jlong jp = jEnv->CallLongMethod (jArg,JMPIjvm::jv.CIMArgumentCInst); |
} |
CIMParamValue *p = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jp); |
|
|
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMInstance__1getClassName |
|
(JNIEnv *jEnv, jobject jThs, jint jInst) |
|
{ |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); |
|
const String &cn = ci->getClassName().getString(); |
|
| |
jstring str=jEnv->NewStringUTF(cn.getCString()); |
JMPIjvm::checkException (jEnv); |
| |
return str; |
in.append (*p); |
|
} |
} | } |
|
try { |
|
checkNs (cop,jNs); |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getQualifier |
CIMValue *val = new CIMValue (cCc->invokeMethod (cop->getNameSpace (), |
(JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN) |
*cop, |
{ |
method, |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); |
in, |
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
out)); |
jint rv = -1; |
|
Uint32 pos = ci->findQualifier(String(str)); |
|
| |
if (pos!=PEG_NOT_FOUND) |
if (jOut) |
{ | { |
rv = DEBUG_ConvertCToJava (CIMQualifier*, jint, new CIMQualifier(ci->getQualifier(pos))); |
for (int i=0,m=out.size(),o=jEnv->GetArrayLength(jOut);i<m && i<o;i++) |
} |
{ |
|
CIMParamValue *parm = new CIMParamValue (out[i]); |
jEnv->ReleaseStringUTFChars(jN,str); |
jlong jParm = DEBUG_ConvertCToJava (CIMParamValue*, jlong, parm); |
| |
return rv; |
jEnv->SetObjectArrayElement( |
|
jOut, |
|
i, |
|
jEnv->NewObject( |
|
JMPIjvm::jv.CIMArgumentClassRef, |
|
JMPIjvm::jv.CIMArgumentNewJ, |
|
jParm)); |
} | } |
|
} |
|
jCv = DEBUG_ConvertCToJava (CIMValue*, jlong, val); |
|
} |
|
Catch (jEnv); |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1clone |
jEnv->ReleaseStringUTFChars (jMn, str); |
(JNIEnv *jEnv, jobject jThs, jint jInst) |
|
{ |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); |
|
CIMInstance *cl = new CIMInstance(ci->clone()); |
|
| |
return DEBUG_ConvertCToJava (CIMInstance*, jint, cl); |
return jCv; |
} | } |
| |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperties |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1associatorNames( |
(JNIEnv *jEnv, jobject jThs, jint jInst, jobject jVec) |
JNIEnv *jEnv, |
|
jobject jThs, |
|
jlong jCc, |
|
jlong jNs, |
|
jlong jCop, |
|
jstring jAssocClass, |
|
jstring jResultClass, |
|
jstring jRole, |
|
jstring jResultRole) |
{ | { |
JMPIjvm::cacheIDs(jEnv); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL); |
| |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); |
CIMName assocClass; |
| |
for (int i=0,s=ci->getPropertyCount(); i<s; i++) { |
if ( str |
CIMProperty *cp = new CIMProperty(ci->getProperty(i)); |
&& *str |
jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); |
) |
|
{ |
|
if (CIMName::legal (str)) |
|
{ |
|
assocClass = str; |
|
} |
|
else |
|
{ |
|
jobject ev = jEnv->NewObject( |
|
JMPIjvm::jv.CIMExceptionClassRef, |
|
JMPIjvm::jv.CIMExceptionNewISt, |
|
(jint)4, // CIM_ERR_INVALID_PARAMETER |
|
jEnv->NewStringUTF( |
|
"Invalid association class name")); |
| |
jobject prop=jEnv->NewObject(JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jCp); |
jEnv->Throw ((jthrowable)ev); |
| |
jEnv->CallVoidMethod(jVec,JMPIjvm::jv.VectorAddElement,prop); |
return 0; |
} | } |
|
|
return jVec; |
|
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1finalize |
jEnv->ReleaseStringUTFChars (jAssocClass,str); |
(JNIEnv *jEnv, jobject jThs, jint jInst) |
|
{ |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); |
|
| |
delete ci; |
str = jEnv->GetStringUTFChars (jResultClass, NULL); |
| |
DEBUG_ConvertCleanup (jint, jInst); |
CIMName resultClass; |
} |
|
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1filterProperties |
if ( str |
(JNIEnv *jEnv, jobject jThs, jint jInst, jobjectArray jPl, jboolean iq, jboolean ic, jboolean lo) |
&& *str |
|
) |
{ | { |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); |
if (CIMName::legal (str)) |
CIMInstance *cf = 0; |
{ |
CIMName clsn = ci->getClassName(); |
resultClass = str; |
|
|
if (lo) { |
|
cf=new CIMInstance(ci->clone()); |
|
CIMName clsn=ci->getClassName(); |
|
for (int i=cf->getPropertyCount()-1; i>=0; i--) |
|
if (cf->getProperty(i).getClassOrigin()==clsn) cf->removeProperty(i); |
|
return DEBUG_ConvertCToJava (CIMInstance*, jint, cf); |
|
} |
|
else if (jPl) { |
|
CIMPropertyList pl=getList(jEnv,jPl); |
|
Array<CIMName> n=pl.getPropertyNameArray(); |
|
cf=new CIMInstance(clsn); |
|
for (int i=0,s=n.size(); i<s; i++) { |
|
Uint32 pos=ci->findProperty(n[i]); |
|
if (pos!=PEG_NOT_FOUND) { |
|
if (iq) { |
|
CIMProperty cp=ci->getProperty(pos).clone(); |
|
if (!ic) cp.setClassOrigin(CIMName()); |
|
cf->addProperty(cp); |
|
} |
|
else { |
|
CIMProperty cp=ci->getProperty(pos); |
|
CIMName co; |
|
if (ic) co=cp.getClassOrigin(); |
|
CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(), |
|
cp.getReferenceClassName(),co,cp.getPropagated()); |
|
cf->addProperty(np); |
|
} |
|
} |
|
} |
|
cf->setPath(ci->getPath()); |
|
} |
|
else if (iq) { |
|
cf=new CIMInstance(ci->clone()); |
|
if (ic) return DEBUG_ConvertCToJava (CIMInstance*, jint, cf); |
|
for (int i=cf->getPropertyCount()-1; i>=0; i--) { |
|
CIMProperty cp=cf->getProperty(i); |
|
cp.setClassOrigin(CIMName()); |
|
cf->removeProperty(i); |
|
cf->addProperty(cp); |
|
} |
|
} | } |
else { |
else |
cf=new CIMInstance(clsn); |
{ |
for (int i=ci->getPropertyCount()-1; i>=0; i--) { |
jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef, |
CIMProperty cp=ci->getProperty(i); |
JMPIjvm::jv.CIMExceptionNewISt, |
CIMName co; |
(jint)4, // CIM_ERR_INVALID_PARAMETER |
if (ic) co=cp.getClassOrigin(); |
jEnv->NewStringUTF( |
CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(), |
"Invalid result class name")); |
cp.getReferenceClassName(),co,cp.getPropagated()); |
|
cf->addProperty(np); |
jEnv->Throw ((jthrowable)ev); |
|
|
|
return 0; |
} | } |
cf->setPath(ci->getPath()); |
|
} | } |
| |
return DEBUG_ConvertCToJava (CIMInstance*, jint, cf); |
jEnv->ReleaseStringUTFChars (jResultClass, str); |
} |
|
| |
/* |
str = jEnv->GetStringUTFChars (jRole, NULL); |
* Class: org_pegasus_jmpi_CIMInstance |
|
* Method: _getObjectPath |
|
* Signature: (I)I |
|
*/ |
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getObjectPath |
|
(JNIEnv *jEnv, jobject jThs, jint jciCi) |
|
{ |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciCi); |
|
CIMObjectPath *copRet = NULL; |
|
| |
try |
String role (str); |
{ |
|
if (ci) |
|
{ |
|
const CIMObjectPath& cop = ci->getPath (); |
|
| |
copRet = new CIMObjectPath (cop); |
jEnv->ReleaseStringUTFChars (jRole, str); |
} |
|
|
str = jEnv->GetStringUTFChars (jResultRole, NULL); |
|
|
|
String resultRole (str); |
|
|
|
jEnv->ReleaseStringUTFChars (jResultRole, str); |
|
|
|
try { |
|
checkNs (cop,jNs); |
|
|
|
Array<CIMObjectPath> enm = cCc->associatorNames (cop->getNameSpace (), |
|
*cop, |
|
assocClass, |
|
resultClass, |
|
role, |
|
resultRole); |
|
return DEBUG_ConvertCToJava( |
|
Array<CIMObjectPath>*, |
|
jlong, |
|
new Array<CIMObjectPath> (enm)); |
} | } |
Catch (jEnv); | Catch (jEnv); |
| |
return DEBUG_ConvertCToJava (CIMObjectPath*, jint, copRet); |
return 0; |
} | } |
| |
/* |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1associators( |
* Class: org_pegasus_jmpi_CIMInstance |
JNIEnv *jEnv, |
* Method: _setObjectPath |
jobject jThs, |
* Signature: (II)V |
jlong jCc, |
*/ |
jlong jNs, |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setObjectPath |
jlong jCop, |
(JNIEnv *jEnv, jobject jThs, jint jciCi, jint jciCop) |
jstring jAssocClass, |
|
jstring jResultClass, |
|
jstring jRole, |
|
jstring jResultRole, |
|
jboolean includeQualifiers, |
|
jboolean includeClassOrigin, |
|
jobjectArray jPl) |
{ | { |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciCi); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jciCop); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
CIMPropertyList pl = getList (jEnv, jPl); |
|
const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL); |
| |
try |
CIMName assocClass; |
{ |
|
if ( ci |
if ( str |
&& cop |
&& *str |
) | ) |
{ | { |
ci->setPath (*cop); |
if (CIMName::legal (str)) |
} |
{ |
} |
assocClass = str; |
Catch (jEnv); |
|
} | } |
|
else |
/* |
|
* Class: org_pegasus_jmpi_CIMInstance |
|
* Method: _getPropertyCount |
|
* Signature: (I)I |
|
*/ |
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getPropertyCount |
|
(JNIEnv *jEnv, jobject jThs, jint jciCi) |
|
{ | { |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciCi); |
jobject ev = jEnv->NewObject(JMPIjvm::jv.CIMExceptionClassRef, |
Uint32 ui32Ret = 0; |
JMPIjvm::jv.CIMExceptionNewISt, |
|
(jint)4, // CIM_ERR_INVALID_PARAMETER |
|
jEnv->NewStringUTF( |
|
"Invalid association class name")); |
| |
try |
jEnv->Throw ((jthrowable)ev); |
{ |
|
if (ci) |
return 0; |
{ |
|
ui32Ret = ci->getPropertyCount (); |
|
} | } |
} | } |
Catch (jEnv); |
|
| |
return ui32Ret; |
jEnv->ReleaseStringUTFChars (jAssocClass, str); |
} |
|
| |
/* |
str = jEnv->GetStringUTFChars (jResultClass, NULL); |
* Class: org_pegasus_jmpi_CIMInstance |
|
* Method: _getProperty |
|
* Signature: (II)I |
|
*/ |
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getPropertyI |
|
(JNIEnv *jEnv, jobject jThs, jint jciCi, jint ji) |
|
{ |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciCi); |
|
CIMProperty *cpRet = NULL; |
|
| |
try |
CIMName resultClass; |
|
|
|
if ( str |
|
&& *str |
|
) |
{ | { |
if (ci) |
if (CIMName::legal (str)) |
{ | { |
CIMProperty cp; |
resultClass = str; |
|
} |
|
else |
|
{ |
|
jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef, |
|
JMPIjvm::jv.CIMExceptionNewISt, |
|
(jint)4, // CIM_ERR_INVALID_PARAMETER |
|
jEnv->NewStringUTF( |
|
"Invalid result class name")); |
| |
cp = ci->getProperty (ji); |
jEnv->Throw ((jthrowable)ev); |
| |
cpRet = new CIMProperty (cp); |
return 0; |
} |
|
} | } |
Catch (jEnv); |
|
|
|
return DEBUG_ConvertCToJava (CIMProperty*, jint, cpRet); |
|
} | } |
| |
// ------------------------------------- |
jEnv->ReleaseStringUTFChars (jResultClass, str); |
// --- |
|
// - CIMObjectPath |
|
// --- |
|
// ------------------------------------- |
|
| |
CIMObjectPath* construct() |
str = jEnv->GetStringUTFChars (jRole, NULL); |
{ |
|
CIMObjectPath *cop = new CIMObjectPath(); |
|
_nameSpace n; |
|
| |
cop->setNameSpace(n.nameSpace()); |
String role (str); |
cop->setHost(n.hostName()); |
|
| |
return cop; |
jEnv->ReleaseStringUTFChars (jRole, str); |
} |
|
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1new |
str = jEnv->GetStringUTFChars (jResultRole, NULL); |
(JNIEnv *jEnv, jobject jThs) |
|
{ |
|
return DEBUG_ConvertCToJava (CIMObjectPath*, jint, construct()); |
|
} |
|
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCn |
String resultRole (str); |
(JNIEnv *jEnv, jobject jThs, jstring jCn) |
|
{ |
|
CIMObjectPath *cop = construct(); |
|
const char *str = jEnv->GetStringUTFChars(jCn,NULL); |
|
| |
if (str) |
jEnv->ReleaseStringUTFChars (jResultRole, str); |
cop->setClassName(str); |
|
| |
jEnv->ReleaseStringUTFChars(jCn,str); |
try { |
|
checkNs (cop, jNs); |
| |
return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); |
Array<CIMObject> enm = cCc->associators (cop->getNameSpace (), |
} |
*cop, |
|
assocClass, |
|
resultClass, |
|
role, |
|
resultRole, |
|
(Boolean)includeQualifiers, |
|
(Boolean)includeClassOrigin, |
|
pl); |
|
Array<CIMInstance> *enmInst = new Array<CIMInstance> (); |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCnNs |
for (int i = 0,m = enm.size (); i<m; i++) |
(JNIEnv *jEnv, jobject jThs, jstring jCn, jstring jNs) |
|
{ | { |
CIMObjectPath *cop = construct(); |
enmInst->append (CIMInstance (enm[i])); |
const char *str1 = NULL; |
} |
const char *str2 = NULL; |
|
| |
try { |
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jlong, enmInst); |
if (jCn) str1=jEnv->GetStringUTFChars(jCn,NULL); |
|
if (jNs) str2=jEnv->GetStringUTFChars(jNs,NULL); |
|
if (str1) cop->setClassName(str1); |
|
if (str2) cop->setNameSpace(str2); |
|
} | } |
Catch(jEnv); | Catch(jEnv); |
| |
if (str1) jEnv->ReleaseStringUTFChars(jCn,str1); |
return 0; |
if (str2) jEnv->ReleaseStringUTFChars(jNs,str2); |
|
|
|
return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); |
|
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1_newCi |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1referenceNames |
(JNIEnv *jEnv, jobject jThs, jint jInst) |
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, |
|
jstring jAssocClass, jstring jRole) |
{ | { |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
CIMObjectPath *cop = new CIMObjectPath(ci->getPath()); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
_nameSpace n; |
const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL); |
| |
if (cop->getNameSpace().isNull()) cop->setNameSpace(n.nameSpace()); |
CIMName assocClass; |
if (cop->getHost()==NULL) cop->setHost(n.hostName()); |
|
| |
return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); |
if ( str |
|
&& *str |
|
) |
|
{ |
|
if (CIMName::legal (str)) |
|
{ |
|
assocClass = str; |
} | } |
|
else |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1finalize |
|
(JNIEnv *jEnv, jobject jThs, jint jCop) |
|
{ | { |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef, |
|
JMPIjvm::jv.CIMExceptionNewISt, |
|
(jint)4, // CIM_ERR_INVALID_PARAMETER |
|
jEnv->NewStringUTF( |
|
"Invalid association class name")); |
| |
delete cop; |
jEnv->Throw ((jthrowable)ev); |
| |
DEBUG_ConvertCleanup (jint, jCop); |
return 0; |
|
} |
} | } |
| |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getHost |
jEnv->ReleaseStringUTFChars (jAssocClass, str); |
(JNIEnv *jEnv, jobject jThs, jint jCop) |
|
{ |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
const String &hn = cop->getHost(); |
|
|
|
jstring str=jEnv->NewStringUTF(hn.getCString()); |
|
| |
return str; |
str = jEnv->GetStringUTFChars (jRole, NULL); |
} |
|
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setHost |
String role (str); |
(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jName) |
|
{ |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
const char *str = jEnv->GetStringUTFChars(jName,NULL); |
|
| |
cop->setHost(String(str)); |
jEnv->ReleaseStringUTFChars (jRole, str); |
| |
jEnv->ReleaseStringUTFChars(jName,str); |
try { |
} |
checkNs (cop, jNs); |
| |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getObjectName |
Array<CIMObjectPath> enm = cCc->referenceNames (cop->getNameSpace (), |
(JNIEnv *jEnv, jobject jThs, jint jCop) |
*cop, |
{ |
assocClass, |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
role); |
const String &cn = cop->getClassName().getString(); |
|
| |
jstring str=jEnv->NewStringUTF(cn.getCString()); |
return DEBUG_ConvertCToJava( |
|
Array<CIMObjectPath>*, |
|
jlong, |
|
new Array<CIMObjectPath> (enm)); |
|
} |
|
Catch (jEnv); |
| |
return str; |
return 0; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setObjectName |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1references |
(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jName) |
(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, |
|
jstring jAssocClass, jstring jRole, |
|
jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl) |
{ | { |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
const char *str = jEnv->GetStringUTFChars(jName,NULL); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
CIMPropertyList pl = getList (jEnv, jPl); |
|
const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL); |
| |
cop->setClassName(String(str)); |
CIMName assocClass; |
| |
jEnv->ReleaseStringUTFChars(jName,str); |
if ( str |
|
&& *str |
|
) |
|
{ |
|
if (CIMName::legal (str)) |
|
{ |
|
assocClass = str; |
} | } |
|
else |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getNameSpace |
|
(JNIEnv *jEnv, jobject jThs, jint jCop) |
|
{ | { |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef, |
const String &ns = cop->getNameSpace().getString(); |
JMPIjvm::jv.CIMExceptionNewISt, |
|
(jint)4, // CIM_ERR_INVALID_PARAMETER |
|
jEnv->NewStringUTF( |
|
"Invalid association class name")); |
| |
jstring str=jEnv->NewStringUTF(ns.getCString()); |
jEnv->Throw ((jthrowable)ev); |
| |
return str; |
return 0; |
|
} |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setNameSpace |
jEnv->ReleaseStringUTFChars (jAssocClass, str); |
(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jName) |
str = jEnv->GetStringUTFChars (jRole, NULL); |
{ |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
const char *str = jEnv->GetStringUTFChars(jName,NULL); |
|
| |
cop->setNameSpace(CIMNamespaceName(str)); |
String role (str); |
| |
jEnv->ReleaseStringUTFChars(jName,str); |
jEnv->ReleaseStringUTFChars (jRole, str); |
} |
|
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1addKey |
try { |
(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jId, jint jVal) |
checkNs (cop, jNs); |
|
|
|
Array<CIMObject> enm = cCc->references (cop->getNameSpace (), |
|
*cop, |
|
assocClass, |
|
role, |
|
(Boolean)includeQualifiers, |
|
(Boolean)includeClassOrigin, |
|
pl); |
|
Array<CIMInstance> *enmInst = new Array<CIMInstance> (); |
|
|
|
for (int i = 0, m = enm.size (); i < m; i++) |
{ | { |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
enmInst->append (CIMInstance (enm[i])); |
const char *str = jEnv->GetStringUTFChars(jId,NULL); |
} |
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jVal); |
|
Array<CIMKeyBinding> keyBindings = cop->getKeyBindings(); |
|
| |
keyBindings.append(CIMKeyBinding(str,*cv)); |
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jlong, enmInst); |
cop->setKeyBindings(Array<CIMKeyBinding>(keyBindings)); |
} |
|
Catch (jEnv); |
| |
jEnv->ReleaseStringUTFChars(jId,str); |
return 0; |
} | } |
| |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeys |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createNameSpace |
(JNIEnv *jEnv, jobject jThs, jint jCop, jobject jVec) |
(JNIEnv *jEnv, jobject jThs, jlong jCc, jstring jNs) |
{ | { |
JMPIjvm::cacheIDs(jEnv); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
const char *str = jEnv->GetStringUTFChars (jNs, NULL); |
|
String ns (str); |
| |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
jEnv->ReleaseStringUTFChars (jNs, str); |
const Array<CIMKeyBinding> &akb = cop->getKeyBindings(); |
|
| |
for (Uint32 i=0,s=akb.size(); i<s; i++) { |
String lastNsComp; |
const String &n=akb[i].getName().getString(); |
String nsBase; |
const String &v=akb[i].getValue(); |
|
CIMKeyBinding::Type t=akb[i].getType(); |
|
CIMValue *cv = 0; |
|
switch (t) { |
|
case CIMKeyBinding::NUMERIC: |
|
cv=new CIMValue((Sint32)atol(v.getCString())); |
|
break; |
|
case CIMKeyBinding::STRING: |
|
cv=new CIMValue(v); |
|
break; |
|
case CIMKeyBinding::BOOLEAN: |
|
cv=new CIMValue((Boolean)(v.getCString())); |
|
break; |
|
case CIMKeyBinding::REFERENCE: |
|
cv = new CIMValue(CIMObjectPath(akb[i].getValue())); |
|
break; |
|
default: |
|
throwCIMException(jEnv,"+++ unsupported type: "); |
|
} |
|
| |
CIMProperty *cp = 0; |
normalizeNs (ns, nsBase, lastNsComp); |
if (t!=CIMKeyBinding::REFERENCE) |
|
cp=new CIMProperty(n,*cv); |
|
else |
|
cp=new CIMProperty(n,*cv, 0, ((CIMObjectPath) akb[i].getValue()).getClassName()); |
|
| |
jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); |
CIMInstance newInstance (CIMName ("__Namespace")); |
jobject prop = jEnv->NewObject(JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jCp); |
newInstance.addProperty(CIMProperty(PEGASUS_PROPERTYNAME_NAME, lastNsComp)); |
| |
jEnv->CallVoidMethod(jVec,JMPIjvm::jv.VectorAddElement,prop); |
try { |
|
cCc->createInstance (CIMNamespaceName (nsBase), newInstance); |
} | } |
|
Catch (jEnv); |
return jVec; |
|
} | } |
| |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeyValue |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateNameSpaces( |
(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jStr) |
JNIEnv *jEnv, |
{ |
jobject jThs, |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
jlong jCc, |
const Array<CIMKeyBinding> &akb = cop->getKeyBindings(); |
jlong jCop, |
const char *strKeyName = jEnv->GetStringUTFChars(jStr,NULL); |
jboolean deep, |
jstring retStr = NULL; |
jobject jVec) |
|
|
for (Uint32 i=0,s=akb.size(); i<s; i++) |
|
{ |
|
const String &n=akb[i].getName().getString(); |
|
|
|
if (n==String(strKeyName)) |
|
{ | { |
retStr=jEnv->NewStringUTF(akb[i].getValue().getCString()); |
JMPIjvm::cacheIDs (jEnv); |
break; |
|
} |
|
} |
|
| |
jEnv->ReleaseStringUTFChars(jStr,strKeyName); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
String ns = cop->getNameSpace ().getString (); |
| |
return retStr; |
try { |
} |
Array<CIMObjectPath> enm = cCc->enumerateInstanceNames( |
|
cop->getNameSpace(), |
|
CIMName("__Namespace")); |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1set |
for (int i = 0, s = enm.size (); i < s; i++) |
(JNIEnv *jEnv, jobject jThs, jstring jStr) |
|
{ | { |
const char *strCop = jEnv->GetStringUTFChars(jStr,NULL); |
CIMObjectPath& cop = enm[i]; |
CIMObjectPath *cop = new CIMObjectPath(); |
const Array<CIMKeyBinding>& kb = cop.getKeyBindings (); |
|
const String& n = kb[0].getValue (); |
| |
cop->set(String(strCop)); |
if (!deep && n.find ('/') != PEG_NOT_FOUND) |
|
continue; |
| |
jEnv->ReleaseStringUTFChars(jStr,strCop); |
String x = ns+"/"+n; |
|
jstring str = jEnv->NewStringUTF (x.getCString ()); |
| |
return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); |
jEnv->CallVoidMethod (jVec, JMPIjvm::jv.VectorAddElement, str); |
|
} |
} | } |
|
Catch (jEnv); |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setKeys |
return jVec; |
(JNIEnv *jEnv, jobject jThs, jint jCop, jobject jVec) |
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteNameSpace |
|
(JNIEnv *jEnv, jobject jThs, jlong jCc, jstring jNs) |
{ | { |
JMPIjvm::cacheIDs(jEnv); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
|
const char *str = jEnv->GetStringUTFChars (jNs,NULL); |
|
String ns (str); |
| |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
jEnv->ReleaseStringUTFChars (jNs,str); |
Array<CIMKeyBinding> akb; |
|
| |
for (Uint32 i=0,s=jEnv->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<s; i++) { |
String lastNsComp; |
jobject o=jEnv->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,(i)); |
String nsBase; |
| |
jint jCp = jEnv->CallIntMethod(o,JMPIjvm::jv.CIMPropertyCInst); |
normalizeNs (ns,nsBase,lastNsComp); |
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jCp); |
|
| |
akb.append(CIMKeyBinding(cp->getName(),cp->getValue())); |
CIMObjectPath cop (String::EMPTY, |
} |
CIMNamespaceName (nsBase), |
cop->setKeyBindings(akb); |
CIMName ("__Namespace")); |
} |
Array<CIMKeyBinding> kb; |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1clone |
kb.append (CIMKeyBinding (PEGASUS_PROPERTYNAME_NAME,CIMValue (lastNsComp))); |
(JNIEnv *jEnv, jobject jThs, jint jCop) |
cop.setKeyBindings (kb); |
{ |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
CIMObjectPath *copl = new CIMObjectPath(cop->getHost(), cop->getNameSpace(), cop->getClassName(), cop->getKeyBindings()); |
|
| |
return DEBUG_ConvertCToJava (CIMObjectPath*, jint, copl); |
try { |
|
cCc->deleteInstance (CIMNamespaceName (nsBase), cop); |
|
} |
|
Catch (jEnv); |
} | } |
| |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1toString |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1finalize |
(JNIEnv *jEnv, jobject jThs, jint jCop) |
(JNIEnv *jEnv, jobject jThs, jlong jCc) |
{ | { |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc); |
const String &ns = cop->toString(); |
|
| |
jstring str=jEnv->NewStringUTF(ns.getCString()); |
delete cCc; |
| |
return str; |
DEBUG_ConvertCleanup (jlong, jCc); |
} | } |
| |
|
|
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
// - CIMDataType | // - CIMDataType |
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1new |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDataType__1new |
(JNIEnv *jEnv, jobject jThs, jint type) | (JNIEnv *jEnv, jobject jThs, jint type) |
{ | { |
return DEBUG_ConvertCToJava (_dataType*, jint, new _dataType(type)); |
return DEBUG_ConvertCToJava (_dataType*, jlong, new _dataType (type)); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newAr |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDataType__1newAr |
(JNIEnv *jEnv, jobject jThs, jint type, jint size) | (JNIEnv *jEnv, jobject jThs, jint type, jint size) |
{ | { |
return DEBUG_ConvertCToJava (_dataType*, jint, new _dataType(type,size)); |
return DEBUG_ConvertCToJava (_dataType*, jlong, new _dataType (type,size)); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newRef |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDataType__1newRef |
(JNIEnv *jEnv, jobject jThs, jint type, jstring jRef) | (JNIEnv *jEnv, jobject jThs, jint type, jstring jRef) |
{ | { |
const char *ref = jEnv->GetStringUTFChars(jRef,NULL); | const char *ref = jEnv->GetStringUTFChars(jRef,NULL); |
jint cInst = DEBUG_ConvertCToJava (_dataType*, jint, new _dataType(type,String(ref))); |
jlong cInst = DEBUG_ConvertCToJava( |
|
_dataType*, |
|
jlong, |
|
new _dataType(type,String (ref))); |
| |
jEnv->ReleaseStringUTFChars(jRef,ref); | jEnv->ReleaseStringUTFChars(jRef,ref); |
| |
return cInst; | return cInst; |
} | } |
| |
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isArray |
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isReference |
(JNIEnv *jEnv, jobject jThs, jint jDt) |
(JNIEnv *jEnv, jobject jThs, jlong jDt) |
{ |
|
_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt); |
|
|
|
return dt->_array==true; |
|
} |
|
|
|
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isreference |
|
(JNIEnv *jEnv, jobject jThs, jint jDt) |
|
{ | { |
_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt); |
_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt); |
| |
return dt->_reference==true; | return dt->_reference==true; |
} | } |
| |
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isReference |
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isArray |
(JNIEnv *jEnv, jobject jThs, jint jDt) |
(JNIEnv *jEnv, jobject jThs, jlong jDt) |
{ | { |
_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt); |
_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt); |
| |
return dt->_reference==true; |
return dt->_array == true; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getType | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getType |
(JNIEnv *jEnv, jobject jThs, jint jDt) |
(JNIEnv *jEnv, jobject jThs, jlong jDt) |
{ | { |
_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt); |
_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt); |
| |
return dt->_type; | return dt->_type; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getSize | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getSize |
(JNIEnv *jEnv, jobject jThs, jint jDt) |
(JNIEnv *jEnv, jobject jThs, jlong jDt) |
{ | { |
_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt); |
_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt); |
| |
return dt->_size; | return dt->_size; |
} | } |
| |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1getRefClassName | JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1getRefClassName |
(JNIEnv *jEnv, jobject jThs, jint jDt) |
(JNIEnv *jEnv, jobject jThs, jlong jDt) |
{ | { |
_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt); |
_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt); |
jstring str = jEnv->NewStringUTF(dt->_refClass.getCString()); | jstring str = jEnv->NewStringUTF(dt->_refClass.getCString()); |
| |
return str; | return str; |
} | } |
| |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1toString | JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1toString |
(JNIEnv *jEnv, jobject jThs, jint jDt) |
(JNIEnv *jEnv, jobject jThs, jlong jDt) |
{ | { |
_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt); |
_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt); |
jstring str = NULL; | jstring str = NULL; |
| |
if (dt->_type & 0x10) | if (dt->_type & 0x10) |
|
|
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDataType__1finalize | JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDataType__1finalize |
(JNIEnv *jEnv, jobject jThs, jint jDt) |
(JNIEnv *jEnv, jobject jThs, jlong jDt) |
{ | { |
_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt); |
_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt); |
| |
delete dt; | delete dt; |
| |
DEBUG_ConvertCleanup (jint, jDt); |
DEBUG_ConvertCleanup (jlong, jDt); |
} | } |
| |
| |
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
// - CIMArgument |
// - CIMDateTime |
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1getValue |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetime |
(JNIEnv *jEnv, jobject jThs, jint jP) |
(JNIEnv *jEnv, jobject jThs, jstring jN) |
{ | { |
CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP); |
const char *str = jEnv->GetStringUTFChars (jN, NULL); |
CIMValue *cv = new CIMValue(cp->getValue()); |
CIMDateTime *dt = 0; |
|
String date; |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
if ( str |
|
&& *str |
|
) |
|
{ |
|
date = str; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1new |
jEnv->ReleaseStringUTFChars (jN, str); |
(JNIEnv *jEnv, jobject jThs) |
|
|
try |
{ | { |
CIMParamValue *p = new CIMParamValue(String::EMPTY,CIMValue()); |
dt = new CIMDateTime (date); |
|
} |
|
Catch (jEnv); |
| |
return DEBUG_ConvertCToJava (CIMParamValue*, jint, p); |
return DEBUG_ConvertCToJava (CIMDateTime*, jlong, dt); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1newS |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetimeempty |
(JNIEnv *jEnv, jobject jThs, jstring jN) |
(JNIEnv *jEnv, jobject jThs) |
{ | { |
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
CIMDateTime *dt = new CIMDateTime (CIMDateTime::getCurrentDateTime ()); |
CIMParamValue *p = new CIMParamValue(str,CIMValue()); |
|
|
|
jEnv->ReleaseStringUTFChars(jN,str); |
|
| |
return DEBUG_ConvertCToJava (CIMParamValue*, jint, p); |
return DEBUG_ConvertCToJava (CIMDateTime*, jlong, dt); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1newSV |
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1after |
(JNIEnv *jEnv, jobject jThs, jstring jN, jint jV) |
(JNIEnv *jEnv, jobject jThs, jlong jC, jlong jD) |
{ | { |
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
CIMDateTime *ct = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jC); |
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); |
CIMDateTime *dt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jD); |
CIMParamValue *p = new CIMParamValue(str,cv); |
jboolean rv = 0; |
| |
jEnv->ReleaseStringUTFChars(jN,str); |
if ( ct |
|
&& dt |
|
) |
|
{ |
|
rv = (jboolean)(ct->getDifference (*ct, *dt) < 0); |
|
} |
| |
return DEBUG_ConvertCToJava (CIMParamValue*, jint, p); |
return rv; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setValue |
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1before |
(JNIEnv *jEnv, jobject jThs, jint jP,jint jV) |
(JNIEnv *jEnv, jobject jThs, jlong jC, jlong jD) |
{ | { |
CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP); |
CIMDateTime *ct = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jC); |
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); |
CIMDateTime *dt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jD); |
|
jboolean rv = 0; |
| |
cp->setValue(*cv); |
if ( ct |
} |
&& dt |
|
) |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMArgument__1getName |
|
(JNIEnv *jEnv, jobject jThs, jint jP) |
|
{ | { |
CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP); |
rv = (jboolean)(ct->getDifference (*ct, *dt) > 0); |
const String &n = cp->getParameterName(); |
} |
jstring str = jEnv->NewStringUTF(n.getCString()); |
|
| |
return str; |
return rv; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setName |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDateTime__1finalize |
(JNIEnv *jEnv, jobject jThs, jint jP, jstring jN) |
(JNIEnv *jEnv, jobject jThs, jlong jDT) |
{ | { |
CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP); |
CIMDateTime *cdt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jDT); |
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
|
String n(str); |
|
| |
cp->setParameterName(n); |
delete cdt; |
| |
jEnv->ReleaseStringUTFChars(jN,str); |
DEBUG_ConvertCleanup (jlong, jDT); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1getType |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDateTime__1getCIMString |
(JNIEnv *jEnv, jobject jThs, jint jP) |
(JNIEnv *jEnv, jobject jThs, jlong jDT) |
{ | { |
CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP); |
CIMDateTime *cdt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jDT); |
const CIMValue cv = cp->getValue(); |
jstring jRet = 0; |
String ref; |
|
bool fSuccess = false; |
|
int iJType = 0; |
|
_dataType *type = 0; |
|
| |
iJType = _dataType::convertCTypeToJavaType (cv.getType(), &fSuccess); |
if (cdt) |
|
{ |
|
String dateString = cdt->toString (); |
| |
if (fSuccess) |
if (dateString.size () > 0) |
{ | { |
type = new _dataType (iJType, |
jRet = jEnv->NewStringUTF (dateString.getCString ()); |
cv.getArraySize(), |
} |
false, |
} |
false, |
|
cv.isArray(), |
return jRet; |
ref, |
} |
true); |
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDateTime__1getMicroseconds |
|
(JNIEnv *jEnv, jobject jThs, jlong jDT) |
|
{ |
|
CIMDateTime *cdt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jDT); |
|
jlong jRet = 0; |
|
|
|
if (cdt) |
|
{ |
|
// Convert from 1 BCE epoch to POSIX 1970 microseconds |
|
jRet = cdt->toMicroSeconds () - PEGASUS_UINT64_LITERAL(62167219200000000); |
} | } |
| |
return DEBUG_ConvertCToJava (_dataType*, jint, type); |
return jRet; |
} | } |
| |
|
|
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
// - CIMProperty |
// - CIMInstance |
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getValue |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1new |
(JNIEnv *jEnv, jobject jThs, jint jP) |
(JNIEnv *jEnv, jobject jThs) |
{ | { |
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
return DEBUG_ConvertCToJava (CIMInstance*, jlong, new CIMInstance ()); |
CIMValue *cv = new CIMValue(cp->getValue()); |
} |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1newCn |
|
(JNIEnv *jEnv, jobject jThs, jstring jN) |
|
{ |
|
const char *str = jEnv->GetStringUTFChars (jN,NULL); |
|
CIMInstance *ci = new CIMInstance (CIMName (str)); |
|
|
|
jEnv->ReleaseStringUTFChars (jN,str); |
|
|
|
return DEBUG_ConvertCToJava (CIMInstance*, jlong, ci); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1new |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1filterProperties( |
(JNIEnv *jEnv, jobject jThs, jstring jN, jint jV) |
JNIEnv *jEnv, |
|
jobject jThs, |
|
jlong jInst, |
|
jobjectArray jPl, |
|
jboolean iq, |
|
jboolean ic, |
|
jboolean lo) |
{ | { |
CIMProperty *p = new CIMProperty(CIMName(),CIMValue()); |
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst); |
|
CIMInstance *cf = 0; |
|
CIMName clsn = ci->getClassName (); |
|
|
|
if (lo) |
|
{ |
|
cf = new CIMInstance (ci->clone ()); |
|
|
|
CIMName clsn = ci->getClassName (); |
|
|
|
for (int i = cf->getPropertyCount () - 1; i >= 0; i--) |
|
{ |
|
if (cf->getProperty (i).getClassOrigin () == clsn) |
|
cf->removeProperty (i); |
|
} |
|
|
|
return DEBUG_ConvertCToJava (CIMInstance*, jlong, cf); |
|
} |
|
else if (jPl) |
|
{ |
|
CIMPropertyList pl = getList (jEnv, jPl); |
|
Array<CIMName> n = pl.getPropertyNameArray (); |
|
|
|
cf = new CIMInstance (clsn); |
|
|
|
for (int i = 0, s = n.size (); i < s; i++) |
|
{ |
|
Uint32 pos = ci->findProperty (n[i]); |
|
|
|
if (pos != PEG_NOT_FOUND) |
|
{ |
|
if (iq) |
|
{ |
|
CIMProperty cp = ci->getProperty (pos).clone (); |
|
|
|
if (!ic) |
|
cp.setClassOrigin (CIMName ()); |
|
|
|
cf->addProperty (cp); |
|
} |
|
else |
|
{ |
|
CIMProperty cp = ci->getProperty (pos); |
|
CIMName co; |
|
|
|
if (ic) |
|
co = cp.getClassOrigin (); |
|
|
|
CIMProperty np (cp.getName (), |
|
cp.getValue (), |
|
cp.getArraySize (), |
|
cp.getReferenceClassName (), |
|
co, |
|
cp.getPropagated ()); |
|
|
|
cf->addProperty (np); |
|
} |
|
} |
|
} |
|
|
|
cf->setPath (ci->getPath ()); |
|
} |
|
else if (iq) |
|
{ |
|
cf = new CIMInstance (ci->clone ()); |
|
|
|
if (ic) |
|
return DEBUG_ConvertCToJava (CIMInstance*, jlong, cf); |
|
|
|
for (int i = cf->getPropertyCount () - 1; i >= 0; i--) |
|
{ |
|
CIMProperty cp = cf->getProperty (i); |
| |
return DEBUG_ConvertCToJava (CIMProperty*, jint, p); |
cp.setClassOrigin (CIMName ()); |
|
cf->removeProperty (i); |
|
cf->addProperty (cp); |
|
} |
|
} |
|
else |
|
{ |
|
cf = new CIMInstance (clsn); |
|
|
|
for (int i = ci->getPropertyCount () - 1; i >= 0; i--) |
|
{ |
|
CIMProperty cp = ci->getProperty (i); |
|
CIMName co; |
|
|
|
if (ic) |
|
co = cp.getClassOrigin (); |
|
|
|
CIMProperty np (cp.getName (), |
|
cp.getValue (), |
|
cp.getArraySize (), |
|
cp.getReferenceClassName (), |
|
co, |
|
cp.getPropagated ()); |
|
|
|
cf->addProperty (np); |
|
} |
|
cf->setPath (ci->getPath ()); |
|
} |
|
|
|
return DEBUG_ConvertCToJava (CIMInstance*, jlong, cf); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1property |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setName |
(JNIEnv *jEnv, jobject jThs, jstring jN, jint jV) |
(JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jN) |
{ | { |
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); |
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst); |
const char *str = jEnv->GetStringUTFChars(jN,NULL); | const char *str = jEnv->GetStringUTFChars(jN,NULL); |
CIMProperty *cp = 0; |
|
jint jCp = -1; |
|
| |
|
jEnv->ReleaseStringUTFChars (jN,str); |
|
|
|
/* NOT SUPPORTED AND NOT NEEDED*/ |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperty |
|
(JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jN, jlong jV) |
|
{ |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst); |
|
CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV); |
|
const char *str = jEnv->GetStringUTFChars (jN, NULL); |
|
Uint32 pos; |
|
|
|
if ( ci |
|
&& cv |
|
) |
|
{ |
try { | try { |
|
pos = ci->findProperty (CIMName (str)); |
|
|
|
if (pos != PEG_NOT_FOUND) |
|
{ |
|
CIMProperty cp = ci->getProperty (pos); |
|
|
|
if (cp.getType () == cv->getType ()) |
|
{ |
|
cp.setValue (*cv); |
|
} |
|
else |
|
{ |
|
throw CIMException( |
|
CIM_ERR_TYPE_MISMATCH, |
|
String ("Property type mismatch")); |
|
} |
|
|
|
ci->removeProperty (pos); |
|
ci->addProperty (cp); |
|
} |
|
else |
|
{ |
|
CIMProperty *cp; |
|
|
if (cv->getType()!=CIMTYPE_REFERENCE) | if (cv->getType()!=CIMTYPE_REFERENCE) |
{ | { |
cp=new CIMProperty(String(str),*cv); |
cp = new CIMProperty (CIMName (str), *cv); |
} | } |
else | else |
{ | { |
|
|
CIMObjectPath cop; | CIMObjectPath cop; |
| |
cv->get(cop); | cv->get(cop); |
cp=new CIMProperty(String(str),*cv,0, cop.getClassName()); |
cp = new CIMProperty(CIMName(str),*cv,0,cop.getClassName()); |
} | } |
else | else |
{ | { |
throwCIMException(jEnv,"+++ unsupported type in CIMProperty.property"); |
throwCIMException( |
|
jEnv, |
|
"+++ unsupported type in CIMProperty.property"); |
} | } |
} | } |
| |
jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); |
ci->addProperty (*cp); |
|
} |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
} |
| |
jEnv->ReleaseStringUTFChars(jN,str); | jEnv->ReleaseStringUTFChars(jN,str); |
|
|
return jCp; |
|
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setValue |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperties |
(JNIEnv *jEnv, jobject jThs, jint jP,jint jV) |
(JNIEnv *jEnv, jobject jThs, jlong jInst, jobject jV) |
{ | { |
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst); |
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); |
|
| |
cp->setValue(*cv); |
if (!ci) |
|
{ |
|
return; |
} | } |
| |
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isArray |
try |
(JNIEnv *jEnv, jobject jThs, jint jP) |
|
{ | { |
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
for (int i = 0, m = jEnv->CallIntMethod (jV, |
|
JMPIjvm::jv.VectorSize); |
|
i < m; |
|
i++) |
|
{ |
|
JMPIjvm::checkException (jEnv); |
| |
return (jboolean)cp->isArray(); |
jobject jProp = jEnv->CallObjectMethod (jV, |
} |
JMPIjvm::jv.VectorElementAt, |
|
i); |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addValue |
JMPIjvm::checkException (jEnv); |
(JNIEnv *jEnv, jobject jThs, jint jP, jint jV) |
|
{ |
|
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
|
CIMValue *cvin = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); |
|
CIMValue cv = cp->getValue(); |
|
| |
if (cvin->isNull()) |
jlong jCpRef = jEnv->CallLongMethod( |
throwCIMException(jEnv,"+++ null cvin value "); |
jProp, |
if (!cv.isArray()) |
JMPIjvm::jv.CIMPropertyCInst); |
throwCIMException(jEnv,"+++ not an array "); |
CIMProperty *cpNew = DEBUG_ConvertJavaToC( |
if (cvin->getType()!=cv.getType()) |
jlong, |
throwCIMException(jEnv,"+++ type mismatch "); |
CIMProperty*, |
|
jCpRef); |
| |
CIMType type=cv.getType(); |
if (cpNew) |
|
{ |
|
Uint32 pos = ci->findProperty (cpNew->getName ()); |
| |
switch (type) { |
if (pos != PEG_NOT_FOUND) |
case CIMTYPE_BOOLEAN: { |
{ |
Boolean bo; |
CIMProperty cpOld = ci->getProperty (pos); |
cvin->get(bo); |
|
Array<Boolean> boarr; |
if (cpOld.getType () == cpNew->getType ()) |
cv.get(boarr); |
{ |
boarr.append(bo); |
ci->removeProperty (pos); |
|
ci->addProperty (*cpNew); |
} | } |
break; |
else |
case CIMTYPE_UINT8: { |
{ |
Uint8 u8; |
throw CIMException( |
cvin->get(u8); |
CIM_ERR_TYPE_MISMATCH, |
Array<Uint8> u8arr; |
String ("Property type mismatch")); |
cv.get(u8arr); |
|
u8arr.append(u8); |
|
} | } |
break; |
|
case CIMTYPE_SINT8: { |
|
Sint8 s8; |
|
cvin->get(s8); |
|
Array<Sint8> s8arr; |
|
cv.get(s8arr); |
|
s8arr.append(s8); |
|
} | } |
break; |
|
case CIMTYPE_UINT16: { |
|
Uint16 u16; |
|
cvin->get(u16); |
|
Array<Uint16> u16arr; |
|
cv.get(u16arr); |
|
u16arr.append(u16); |
|
} | } |
break; |
|
case CIMTYPE_SINT16: { |
|
Sint16 s16; |
|
cvin->get(s16); |
|
Array<Sint16> s16arr; |
|
cv.get(s16arr); |
|
s16arr.append(s16); |
|
} | } |
break; |
|
case CIMTYPE_UINT32: { |
|
Uint32 u32; |
|
cvin->get(u32); |
|
Array<Uint32> u32arr; |
|
cv.get(u32arr); |
|
u32arr.append(u32); |
|
} | } |
break; |
Catch (jEnv); |
case CIMTYPE_SINT32: { |
|
Sint32 s32; |
|
cvin->get(s32); |
|
Array<Sint32> s32arr; |
|
cv.get(s32arr); |
|
s32arr.append(s32); |
|
} | } |
break; |
|
case CIMTYPE_UINT64: { |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperty |
Uint64 u64; |
(JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jN) |
cvin->get(u64); |
{ |
Array<Uint64> u64arr; |
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst); |
cv.get(u64arr); |
const char *str = jEnv->GetStringUTFChars (jN, NULL); |
u64arr.append(u64); |
jlong rv = 0; |
|
|
|
try { |
|
Uint32 pos = ci->findProperty (CIMName (str)); |
|
|
|
if (pos != PEG_NOT_FOUND) |
|
{ |
|
CIMProperty *cp = new CIMProperty (ci->getProperty (pos)); |
|
|
|
rv = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp); |
} | } |
break; |
|
case CIMTYPE_SINT64: { |
|
Sint64 s64; |
|
cvin->get(s64); |
|
Array<Sint64> s64arr; |
|
cv.get(s64arr); |
|
s64arr.append(s64); |
|
} |
|
break; |
|
case CIMTYPE_REAL32: { |
|
Real32 f; |
|
cvin->get(f); |
|
Array<Real32> farr; |
|
cv.get(farr); |
|
farr.append(f); |
|
} |
|
break; |
|
case CIMTYPE_REAL64: { |
|
Real64 d; |
|
cvin->get(d); |
|
Array<Real64> darr; |
|
cv.get(darr); |
|
darr.append(d); |
|
} | } |
break; |
Catch (jEnv); |
case CIMTYPE_CHAR16: { |
|
Char16 c16; |
jEnv->ReleaseStringUTFChars (jN, str); |
cvin->get(c16); |
|
Array<Char16> c16arr; |
return rv; |
cv.get(c16arr); |
|
c16arr.append(c16); |
|
} |
|
break; |
|
case CIMTYPE_STRING: { |
|
String str; |
|
cvin->get(str); |
|
Array<String> strarr; |
|
cv.get(strarr); |
|
strarr.append(str); |
|
} | } |
break; |
|
case CIMTYPE_DATETIME: { |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getKeyValuePairs |
CIMDateTime dt; |
(JNIEnv *jEnv, jobject jThs, jlong jInst, jobject jVec) |
cvin->get(dt); |
{ |
Array<CIMDateTime> dtarr; |
JMPIjvm::cacheIDs (jEnv); |
cv.get(dtarr); |
|
dtarr.append(dt); |
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst); |
|
|
|
if ( ci |
|
&& CIMNamespaceName::legal (ci->getPath ().getNameSpace ().getString ()) |
|
) |
|
{ |
|
CIMOMHandle ch; |
|
OperationContext oc; |
|
CIMClass cc; |
|
|
|
cc = ch.getClass (oc, |
|
ci->getPath ().getNameSpace (), |
|
ci->getClassName (), |
|
false, // localOnly |
|
true, // includeQualifiers |
|
true, // includeClassOrigin |
|
CIMPropertyList ());// propertyList |
|
|
|
if (!cc.hasKeys ()) |
|
{ |
|
return jVec; |
} | } |
break; |
|
case CIMTYPE_REFERENCE: { |
Array<CIMName> keyNames; |
CIMObjectPath ref; |
|
cvin->get(ref); |
cc.getKeyNames (keyNames); |
Array<CIMObjectPath> refarr; |
|
cv.get(refarr); |
for (Uint32 i = 0; i < keyNames.size (); i++) |
refarr.append(ref); |
{ |
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"finding key %s ", |
|
(const char*)keyNames[i].getString().getCString())); |
|
|
|
for (Uint32 j = 0; j < ci->getPropertyCount (); j++) |
|
{ |
|
CIMProperty cp = ci->getProperty (j); |
|
|
|
if (cp.getName () == keyNames[i]) |
|
{ |
|
PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, |
|
"adding key (%d) %s ",i, |
|
(const char*)keyNames[i].getString().getCString())); |
|
|
|
CIMProperty *cpRef = new CIMProperty (cp); |
|
jlong jCpRef = DEBUG_ConvertCToJava (CIMProperty*, jlong, cpRef); |
|
jobject jProp = jEnv->NewObject( |
|
JMPIjvm::jv.CIMPropertyClassRef, |
|
JMPIjvm::jv.CIMPropertyNewJ, |
|
jCpRef); |
|
|
|
jEnv->CallVoidMethod (jVec, |
|
JMPIjvm::jv.VectorAddElement, |
|
jProp); |
} | } |
break; |
|
case CIMTYPE_OBJECT: { |
|
CIMObject obj; |
|
cvin->get(obj); |
|
Array<CIMObject> objarr; |
|
cv.get(objarr); |
|
objarr.append(obj); |
|
} | } |
break; |
|
default: |
|
throwCIMException(jEnv,"+++ unsupported type "); |
|
} | } |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addQualifier |
return jVec; |
(JNIEnv *jEnv, jobject jThs, jint jP, jint jQ) |
|
{ |
|
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
|
CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ); |
|
|
|
cp->addQualifier(*cq); |
|
} | } |
| |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getName |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperties |
(JNIEnv *jEnv, jobject jThs, jint jP) |
(JNIEnv *jEnv, jobject jThs, jlong jInst, jobject jVec) |
{ | { |
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
JMPIjvm::cacheIDs (jEnv); |
const String &n = cp->getName().getString(); |
|
jstring str = jEnv->NewStringUTF(n.getCString()); |
|
| |
return str; |
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst); |
} |
|
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setName |
for (int i = 0, s = ci->getPropertyCount (); i < s; i++) |
(JNIEnv *jEnv, jobject jThs, jint jP, jstring jN) |
|
{ | { |
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
CIMProperty *cp = new CIMProperty (ci->getProperty (i)); |
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
jlong jCp = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp); |
| |
cp->setName(CIMName(str)); |
jobject prop = jEnv->NewObject( |
|
JMPIjvm::jv.CIMPropertyClassRef, |
|
JMPIjvm::jv.CIMPropertyNewJ, |
|
jCp); |
| |
jEnv->ReleaseStringUTFChars(jN,str); |
jEnv->CallVoidMethod(jVec,JMPIjvm::jv.VectorAddElement,prop); |
} | } |
| |
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isReference |
return jVec; |
(JNIEnv *jEnv, jobject jThs, jint jP) |
|
{ |
|
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
|
|
|
return (jboolean)(cp->getType()==CIMTYPE_REFERENCE); |
|
} | } |
| |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getRefClassName |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMInstance__1getClassName( |
(JNIEnv *jEnv, jobject jThs, jint jP) |
JNIEnv *jEnv, |
|
jobject jThs, |
|
jlong jInst) |
{ | { |
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst); |
const String &n = cp->getReferenceClassName().getString(); |
const String &cn = ci->getClassName ().getString (); |
| |
jstring str=jEnv->NewStringUTF(n.getCString()); |
jstring str = jEnv->NewStringUTF (cn.getCString ()); |
| |
return str; | return str; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getType |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1getQualifier |
(JNIEnv *jEnv, jobject jThs, jint jP) |
(JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jN) |
{ | { |
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst); |
String ref = cp->getReferenceClassName().getString(); |
const char *str = jEnv->GetStringUTFChars (jN, NULL); |
bool fSuccess = false; |
jlong rv = 0; |
int iJType = 0; |
Uint32 pos; |
_dataType *type = 0; |
|
| |
iJType = _dataType::convertCTypeToJavaType (cp->getType(), &fSuccess); |
if (ci) |
|
{ |
|
try |
|
{ |
|
CIMOMHandle ch; |
|
OperationContext oc; |
|
CIMClass cc; |
|
|
|
cc = ch.getClass (oc, |
|
ci->getPath ().getNameSpace (), |
|
ci->getClassName (), |
|
false, // localOnly |
|
true, // includeQualifiers |
|
true, // includeClassOrigin |
|
CIMPropertyList ()); // propertyList |
| |
if (fSuccess) |
pos = cc.findQualifier (String (str)); |
|
|
|
if (pos != PEG_NOT_FOUND) |
{ | { |
type = new _dataType (iJType, |
CIMQualifier *cq = 0; |
cp->getArraySize(), |
|
ref.size() ? true : false, |
cq = new CIMQualifier (cc.getQualifier (pos)); |
false, |
|
cp->isArray(), |
rv = DEBUG_ConvertCToJava (CIMQualifier*, jlong, cq); |
ref, |
|
true); |
|
} | } |
|
} |
|
Catch (jEnv); |
|
} |
|
|
|
jEnv->ReleaseStringUTFChars (jN, str); |
| |
return DEBUG_ConvertCToJava (_dataType*, jint, type); |
return rv; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1setType |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1clone |
(JNIEnv *jEnv, jobject jThs, jint jP, jint jDt) |
(JNIEnv *jEnv, jobject jThs, jlong jInst) |
{ | { |
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst); |
_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt); |
CIMInstance *cl = new CIMInstance (ci->clone ()); |
CIMValue val; |
|
bool fSuccess = false; |
|
CIMType cType = CIMTYPE_BOOLEAN; |
|
| |
cType = _dataType::convertJavaTypeToCType (dt->_type, &fSuccess); |
return DEBUG_ConvertCToJava (CIMInstance*, jlong, cl); |
|
} |
| |
if (fSuccess) |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1finalize |
|
(JNIEnv *jEnv, jobject jThs, jlong jInst) |
{ | { |
val.setNullValue (cType, dt->_array); |
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst); |
| |
CIMProperty *np = new CIMProperty (cp->getName (), val); |
delete ci; |
| |
delete cp; |
DEBUG_ConvertCleanup (jlong, jInst); |
|
} |
| |
DEBUG_ConvertCleanup (jint, jP); |
/* |
|
* Class: org_pegasus_jmpi_CIMInstance |
|
* Method: _getObjectPath |
|
* Signature: (I)I |
|
*/ |
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1getObjectPath |
|
(JNIEnv *jEnv, jobject jThs, jlong jciCi) |
|
{ |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciCi); |
|
CIMObjectPath *copRet = NULL; |
| |
return DEBUG_ConvertCToJava (CIMProperty*, jint, np); |
try |
} |
{ |
else |
if (ci) |
{ | { |
return DEBUG_ConvertCToJava (CIMProperty*, jint, cp); |
const CIMObjectPath& cop = ci->getPath (); |
|
|
|
copRet = new CIMObjectPath (cop); |
} | } |
} | } |
|
Catch (jEnv); |
| |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMProperty__1getIdentifier |
return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, copRet); |
(JNIEnv *jEnv, jobject jThs, jint jP) |
|
{ |
|
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
|
const String &n = cp->getName().getString(); |
|
jstring str = jEnv->NewStringUTF(n.getCString()); |
|
|
|
return str; |
|
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1finalize |
/* |
(JNIEnv *jEnv, jobject jThs, jint jP) |
* Class: org_pegasus_jmpi_CIMInstance |
|
* Method: _setObjectPath |
|
* Signature: (II)V |
|
*/ |
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setObjectPath |
|
(JNIEnv *jEnv, jobject jThs, jlong jciCi, jlong jciCop) |
{ | { |
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciCi); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jciCop); |
delete cp; |
|
| |
DEBUG_ConvertCleanup (jint, jP); |
try |
|
{ |
|
if ( ci |
|
&& cop |
|
) |
|
{ |
|
ci->setPath (*cop); |
|
} |
|
} |
|
Catch (jEnv); |
} | } |
| |
/* | /* |
* Class: org_pegasus_jmpi_CIMProperty |
* Class: org_pegasus_jmpi_CIMInstance |
* Method: _findQualifier |
* Method: _getPropertyCount |
* Signature: (Ljava/lang/String;)I |
* Signature: (I)I |
*/ | */ |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1findQualifier |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getPropertyCount |
(JNIEnv *jEnv, jobject jThs, jint jP, jstring jQualifier) |
(JNIEnv *jEnv, jobject jThs, jlong jciCi) |
{ | { |
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciCi); |
const char *str = jEnv->GetStringUTFChars (jQualifier, NULL); |
Uint32 ui32Ret = 0; |
int index = PEG_NOT_FOUND; |
|
| |
try | try |
{ | { |
index = cp->findQualifier (CIMName (str)); |
if (ci) |
|
{ |
jEnv->ReleaseStringUTFChars (jQualifier, str); |
ui32Ret = ci->getPropertyCount (); |
|
} |
} | } |
Catch (jEnv); | Catch (jEnv); |
| |
return index; |
return ui32Ret; |
} | } |
| |
/* | /* |
* Class: org_pegasus_jmpi_CIMProperty |
* Class: org_pegasus_jmpi_CIMInstance |
* Method: _getQualifier |
* Method: _getProperty |
* Signature: (I)I |
* Signature: (II)I |
*/ | */ |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getQualifier |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1getPropertyI |
(JNIEnv *jEnv, jobject jThs, jint jP, jint jIndex) |
(JNIEnv *jEnv, jobject jThs, jlong jciCi, jint ji) |
{ | { |
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciCi); |
CIMQualifier *cq = NULL; |
CIMProperty *cpRet = NULL; |
CIMQualifier qualifier; |
|
| |
try | try |
{ | { |
qualifier = cp->getQualifier ((Uint32)jIndex); |
if (ci) |
cq = new CIMQualifier (qualifier); |
{ |
|
CIMProperty cp; |
|
|
|
cp = ci->getProperty (ji); |
|
|
|
cpRet = new CIMProperty (cp); |
|
} |
} | } |
Catch (jEnv); | Catch (jEnv); |
| |
return DEBUG_ConvertCToJava (CIMQualifier *, jint, cq); |
return DEBUG_ConvertCToJava (CIMProperty*, jlong, cpRet); |
} | } |
| |
| |
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
// - CIMQualifierType |
// - CIMMethod |
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1new |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1getType |
(JNIEnv *jEnv, jobject jThs) |
(JNIEnv *jEnv, jobject jThs, jlong jM) |
{ | { |
CIMQualifierDecl *qual = new CIMQualifierDecl(); |
CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM); |
|
bool fSuccess = false; |
return DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, qual); |
jint jType = 0; |
} |
|
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1finalize |
if (cm) |
(JNIEnv *jEnv, jobject jThs, jint jQ) |
|
{ | { |
CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ); |
CIMType ct = cm->getType (); |
| |
delete qt; |
jType = _dataType::convertCTypeToJavaType (ct, &fSuccess); |
|
} |
| |
DEBUG_ConvertCleanup (jint, jQ); |
return jType; |
} | } |
| |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1getName |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMMethod__1getName |
(JNIEnv *jEnv, jobject jThs, jint jQ) |
(JNIEnv *jEnv, jobject jThs, jlong jM) |
{ | { |
CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ); |
CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM); |
const String &n = qt->getName().getString(); |
jstring str = 0; |
jstring str = jEnv->NewStringUTF(n.getCString()); |
|
|
if (cm) |
|
{ |
|
CIMName cn = cm->getName (); |
|
|
|
str = jEnv->NewStringUTF (cn.getString ().getCString ()); |
|
} |
| |
return str; | return str; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setName |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1findParameter |
(JNIEnv *jEnv, jobject jThs, jint jQ, jstring jN) |
(JNIEnv *jEnv, jobject jThs, jlong jM, jstring jName) |
{ | { |
CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ); |
CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM); |
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
jint rv = -1; |
jint jret = 0; |
|
| |
if (qt->isUninitialized()) |
if (cm && jName) |
{ | { |
CIMQualifierDecl *nqt = new CIMQualifierDecl(CIMName(str),CIMValue(),CIMScope()); |
const char *cstrName = jEnv->GetStringUTFChars (jName, NULL); |
| |
jret = DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, nqt); |
try |
} |
|
else |
|
{ | { |
qt->setName(CIMName(str)); |
CIMName name (cstrName); |
|
|
CIMQualifierDecl *nqt = new CIMQualifierDecl(*qt); |
|
| |
jret = DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, nqt); |
rv = cm->findParameter (name); |
} | } |
|
Catch (jEnv); |
| |
jEnv->ReleaseStringUTFChars(jN,str); |
jEnv->ReleaseStringUTFChars (jName, cstrName); |
|
} |
| |
return jret; |
return rv; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setValue |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMMethod__1getParameter |
(JNIEnv *jEnv, jobject jThs, jint jQ,jint jV) |
(JNIEnv *jEnv, jobject jThs, jlong jM, jint jParameter) |
{ | { |
CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ); |
CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM); |
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); |
jlong rv = 0; |
| |
qt->setValue(*cv); |
if (cm && jParameter >= 0) |
|
{ |
|
try |
|
{ |
|
CIMParameter cp = cm->getParameter (jParameter); |
|
|
|
rv = DEBUG_ConvertCToJava(CIMParameter *, jlong, new CIMParameter(cp)); |
|
} |
|
Catch (jEnv); |
|
} |
|
|
|
return rv; |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1getParameterCount |
|
(JNIEnv *jEnv, jobject jThs, jlong jM) |
|
{ |
|
CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM); |
|
jint rv = 0; |
|
|
|
if (cm) |
|
{ |
|
try |
|
{ |
|
rv = cm->getParameterCount (); |
|
} |
|
Catch (jEnv); |
|
} |
|
|
|
return rv; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize |
|
(JNIEnv *jEnv, jobject jThs, jlong jM) |
|
{ |
|
CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM); |
|
|
|
delete cm; |
|
|
|
DEBUG_ConvertCleanup (jlong, jM); |
} | } |
| |
|
|
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
// - CIMQualifier |
// - CIMNameSpace |
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifier__1new |
_nameSpace::_nameSpace () |
(JNIEnv *jEnv, jobject jThs, jstring jN) |
|
{ | { |
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
port_ = 0; |
CIMQualifier *qual = new CIMQualifier(CIMName(str),CIMValue()); |
hostName_ = System::getHostName (); |
|
nameSpace_ = "root/cimv2"; |
|
fHttps = false; |
|
} |
| |
jEnv->ReleaseStringUTFChars(jN,str); |
_nameSpace::_nameSpace (String hn) |
|
{ |
|
port_ = 0; |
|
hostName_ = hn; |
|
nameSpace_ = "root/cimv2"; |
|
fHttps = false; |
|
} |
| |
return DEBUG_ConvertCToJava (CIMQualifier*, jint, qual); |
_nameSpace::_nameSpace (String hn, String ns) |
|
{ |
|
port_ = 0; |
|
hostName_ = hn; |
|
nameSpace_ = ns; |
|
fHttps = false; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1finalize |
int _nameSpace::port () |
(JNIEnv *jEnv, jobject jThs, jint jQ) |
|
{ | { |
CIMQualifier *cq=DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ); |
if (port_) |
|
return port_; |
| |
delete cq; |
port_ = 5988; |
| |
DEBUG_ConvertCleanup (jint, jQ); |
if (hostName_.subString (0,7) == "http://") |
|
{ |
|
protocol_ = hostName_.subString (0,7); |
|
hostName_ = hostName_.subString (7); |
|
} |
|
else if (hostName_.subString (0,8) == "https://") |
|
{ |
|
protocol_ = hostName_.subString (0,8); |
|
hostName_ = hostName_.subString (8); |
|
fHttps = true; |
} | } |
| |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getName |
Sint32 p = hostName_.reverseFind (':'); |
(JNIEnv *jEnv, jobject jThs, jint jQ) |
|
|
if (p >= 0) |
{ | { |
CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ); |
if ((hostName_[p+1] >= '0') && (hostName_[p+1] <= '9')) |
const String &n = cq->getName().getString(); |
port_ = atoi (hostName_.subString (p+1).getCString ()); |
jstring str = jEnv->NewStringUTF(n.getCString()); |
|
| |
return str; |
hostName_.remove (p); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getValue |
return port_; |
(JNIEnv *jEnv, jobject jThs, jint jQ) |
} |
{ |
|
CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ); |
|
CIMValue *cv = new CIMValue(cq->getValue()); |
|
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
String _nameSpace::hostName () |
|
{ |
|
port (); |
|
return hostName_; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1setValue |
String _nameSpace::nameSpace () |
(JNIEnv *jEnv, jobject jThs, jint jQ,jint jV) |
|
{ | { |
CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ); |
return nameSpace_; |
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); |
} |
| |
cq->setValue(*cv); |
Boolean _nameSpace::isHttps () |
|
{ |
|
port (); |
|
return fHttps; |
} | } |
| |
// ------------------------------------- |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1new |
// --- |
(JNIEnv *jEnv, jobject jThs) |
// - CIMDateTime |
{ |
// --- |
return DEBUG_ConvertCToJava (_nameSpace*, jlong, new _nameSpace ()); |
// ------------------------------------- |
} |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetime |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHn |
(JNIEnv *jEnv, jobject jThs, jstring jN) |
(JNIEnv *jEnv, jobject jThs, jstring jHn) |
{ | { |
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
const char *hn = jEnv->GetStringUTFChars (jHn, NULL); |
CIMDateTime *dt = 0; |
jlong cInst = DEBUG_ConvertCToJava(_nameSpace*, jlong, new _nameSpace(hn)); |
| |
if (strlen(str)==0) |
jEnv->ReleaseStringUTFChars (jHn, hn); |
dt=new CIMDateTime(); |
|
else |
|
dt=new CIMDateTime(String(str)); |
|
| |
jEnv->ReleaseStringUTFChars(jN,str); |
return cInst; |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHnNs |
|
(JNIEnv *jEnv, jobject jThs, jstring jHn, jstring jNs) |
|
{ |
|
const char *hn = jEnv->GetStringUTFChars (jHn, NULL); |
|
const char *ns = jEnv->GetStringUTFChars (jNs, NULL); |
|
jlong cInst = DEBUG_ConvertCToJava( |
|
_nameSpace*, |
|
jlong, |
|
new _nameSpace(String (hn),String (ns))); |
|
|
|
jEnv->ReleaseStringUTFChars (jHn, hn); |
|
jEnv->ReleaseStringUTFChars (jNs, ns); |
| |
return DEBUG_ConvertCToJava (CIMDateTime*, jint, dt); |
return cInst; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetimeempty |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getNameSpace |
(JNIEnv *jEnv, jobject jThs) |
(JNIEnv *jEnv, jobject jThs, jlong jNs) |
{ | { |
CIMDateTime *dt = new CIMDateTime(CIMDateTime::getCurrentDateTime ()); |
_nameSpace *cNs = DEBUG_ConvertJavaToC (jlong, _nameSpace*, jNs); |
|
const String &ns = cNs->nameSpace_; |
|
jstring str = jEnv->NewStringUTF (ns.getCString ()); |
| |
return DEBUG_ConvertCToJava (CIMDateTime*, jint, dt); |
return str; |
} | } |
| |
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1after |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getHost |
(JNIEnv *jEnv, jobject jThs, jint jC, jint jD) |
(JNIEnv *jEnv, jobject jThs, jlong jNs) |
{ | { |
CIMDateTime *ct = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jC); |
_nameSpace *cNs = DEBUG_ConvertJavaToC (jlong, _nameSpace*, jNs); |
CIMDateTime *dt = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jD); |
const String &hn = cNs->hostName_; |
|
jstring str = jEnv->NewStringUTF (hn.getCString ()); |
| |
return (jboolean)(ct->getDifference(*ct, *dt)>0); |
return str; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDateTime__1finalize |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setNameSpace |
(JNIEnv *jEnv, jobject jThs, jint jDT) |
(JNIEnv *jEnv, jobject jThs, jlong jNs, jstring jN) |
{ | { |
CIMDateTime *cdt = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jDT); |
_nameSpace *cNs = DEBUG_ConvertJavaToC (jlong, _nameSpace*, jNs); |
|
const char *str = jEnv->GetStringUTFChars (jN, NULL); |
| |
delete cdt; |
cNs->nameSpace_ = str; |
| |
DEBUG_ConvertCleanup (jint, jDT); |
jEnv->ReleaseStringUTFChars (jN, str); |
} | } |
| |
// ------------------------------------- |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setHost |
// --- |
(JNIEnv *jEnv, jobject jThs, jlong jNs, jstring jHn) |
// - CIMMethod |
|
// --- |
|
// ------------------------------------- |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1getType |
|
(JNIEnv *jEnv, jobject jThs, jint jM) |
|
{ | { |
CIMMethod *cm = DEBUG_ConvertJavaToC (jint, CIMMethod*, jM); |
_nameSpace *cNs = DEBUG_ConvertJavaToC (jlong, _nameSpace*, jNs); |
|
const char *str = jEnv->GetStringUTFChars (jHn, NULL); |
|
|
|
cNs->port_ = 0; |
|
cNs->hostName_ = str; |
| |
return DEBUG_ConvertCToJava (CIMType *, jint, new CIMType (cm->getType())); |
jEnv->ReleaseStringUTFChars (jHn, str); |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1finalize |
(JNIEnv *jEnv, jobject jThs, jint jM) |
(JNIEnv *jEnv, jobject jThs, jlong jNs) |
{ | { |
CIMMethod *cm = DEBUG_ConvertJavaToC (jint, CIMMethod*, jM); |
_nameSpace *cNs = DEBUG_ConvertJavaToC (jlong, _nameSpace*, jNs); |
| |
delete cm; |
delete cNs; |
| |
DEBUG_ConvertCleanup (jint, jM); |
DEBUG_ConvertCleanup (jlong, jNs); |
} | } |
| |
|
|
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
// - CIMValue |
// - CIMObject |
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObject__1newClass |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byte |
(JNIEnv *jEnv, jobject jThs, jlong jCc) |
(JNIEnv *jEnv, jobject jThs, jbyte jb, jboolean notSigned) |
|
{ | { |
CIMValue *cv = NULL; |
CIMClass *cCc = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCc); |
| |
if (notSigned) |
try { |
cv=new CIMValue((Uint8)jb); |
CIMObject *cCo = new CIMObject (*cCc); |
else |
|
cv=new CIMValue((Sint8)jb); |
|
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
return DEBUG_ConvertCToJava (CIMObject*, jlong, cCo); |
} | } |
|
Catch (jEnv); |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1short |
return 0; |
(JNIEnv *jEnv, jobject jThs, jshort js, jboolean notSigned) |
|
{ |
|
CIMValue *cv = NULL; |
|
|
|
if (notSigned) |
|
cv=new CIMValue((Uint16)js); |
|
else |
|
cv=new CIMValue((Sint16)js); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
|
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1makeInt |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObject__1newInstance |
(JNIEnv *jEnv, jobject jThs, jlong ji, jboolean notSigned) |
(JNIEnv *jEnv, jobject jThs, jlong jCi) |
{ | { |
CIMValue *cv = NULL; |
CIMInstance *cCi = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jCi); |
| |
if (notSigned) |
try { |
cv = new CIMValue((Uint32)ji); |
CIMObject *cCo = new CIMObject (*cCi); |
else |
|
cv = new CIMValue((Sint32)ji); |
|
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
return DEBUG_ConvertCToJava (CIMObject*, jlong, cCo); |
} | } |
|
Catch (jEnv); |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1long |
return 0; |
(JNIEnv *jEnv, jobject jThs, jlong jl, jboolean notSigned) |
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObject__1finalize |
|
(JNIEnv *jEnv, jobject jThs, jlong jInst) |
{ | { |
CIMValue *cv = NULL; |
CIMObject *co = DEBUG_ConvertJavaToC (jlong, CIMObject*, jInst); |
| |
if (notSigned) |
delete co; |
cv=new CIMValue((Uint64)jl); |
|
else |
|
cv=new CIMValue((Sint64)jl); |
|
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
DEBUG_ConvertCleanup (jlong, jInst); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1float |
|
(JNIEnv *jEnv, jobject jThs, jfloat jF) |
// ------------------------------------- |
|
// --- |
|
// - CIMObjectPath |
|
// --- |
|
// ------------------------------------- |
|
|
|
CIMObjectPath* construct () |
{ | { |
CIMValue *cv = new CIMValue(jF); |
CIMObjectPath *cop = new CIMObjectPath (); |
|
_nameSpace n; |
|
|
|
cop->setNameSpace (n.nameSpace ()); |
|
cop->setHost (n.hostName ()); |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
return cop; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1double |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1new |
(JNIEnv *jEnv, jobject jThs, jdouble jD) |
(JNIEnv *jEnv, jobject jThs) |
{ | { |
CIMValue *cv = new CIMValue(jD); |
return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, construct ()); |
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
|
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1string |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCn |
(JNIEnv *jEnv, jobject jThs, jstring jS) |
(JNIEnv *jEnv, jobject jThs, jstring jCn) |
{ | { |
const char *str = jEnv->GetStringUTFChars(jS,NULL); |
CIMObjectPath *cop = construct (); |
CIMValue *cv = new CIMValue(String(str)); |
const char *str = jEnv->GetStringUTFChars (jCn, NULL); |
| |
jEnv->ReleaseStringUTFChars(jS,str); |
if (str) |
|
cop->setClassName (str); |
|
|
|
jEnv->ReleaseStringUTFChars (jCn, str); |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1cop |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCnNs |
(JNIEnv *jEnv, jobject jThs, jint jR) |
(JNIEnv *jEnv, jobject jThs, jstring jCn, jstring jNs) |
{ | { |
CIMObjectPath *ref = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jR); |
CIMObjectPath *cop = construct (); |
CIMValue *cv = new CIMValue(*ref); |
const char *str1 = NULL; |
|
const char *str2 = NULL; |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
try { |
|
if (jCn) |
|
str1 = jEnv->GetStringUTFChars (jCn, NULL); |
|
if (jNs) |
|
str2 = jEnv->GetStringUTFChars (jNs, NULL); |
|
if (str1) |
|
cop->setClassName (str1); |
|
if (str2) |
|
cop->setNameSpace (str2); |
} | } |
|
Catch (jEnv); |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1datetime |
if (str1) |
(JNIEnv *jEnv, jobject jThs, jint jDT) |
jEnv->ReleaseStringUTFChars (jCn, str1); |
{ |
if (str2) |
CIMDateTime *dt = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jDT); |
jEnv->ReleaseStringUTFChars (jNs, str2); |
CIMValue *cv = new CIMValue(*dt); |
|
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1char16 |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCi |
(JNIEnv *jEnv, jobject jThs, jchar jChar16) |
(JNIEnv *jEnv, jobject jThs, jlong jInst) |
{ | { |
Char16 c16 (jChar16); |
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst); |
CIMValue *cv = new CIMValue(c16); |
CIMObjectPath *cop = 0; |
|
_nameSpace n; |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
try |
} |
{ |
|
if (ci) |
|
{ |
|
cop = new CIMObjectPath (ci->getPath ()); |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1object |
if (cop) |
(JNIEnv *jEnv, jobject jThs, jint jO) |
|
{ | { |
CIMObject *co = DEBUG_ConvertJavaToC (jint, CIMObject*, jO); |
if (cop->getNameSpace ().isNull ()) |
CIMValue *cv = new CIMValue(*co); |
cop->setNameSpace (n.nameSpace ()); |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
if (cop->getHost ().size () == 0) |
|
cop->setHost (n.hostName ()); |
} | } |
|
} |
|
} |
|
Catch (jEnv); |
| |
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMValue__1isArray |
return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop); |
(JNIEnv *jEnv, jobject jThs, jint jP) |
|
{ |
|
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jP); |
|
|
|
return (jboolean)cv->isArray(); |
|
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1boolean |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCiNs |
(JNIEnv *jEnv, jobject jThs, jboolean jB) |
(JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jNamespace) |
{ | { |
CIMValue *cv = new CIMValue((Boolean)jB); |
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInst); |
|
CIMObjectPath *cop = 0; |
|
const char *pszNamespace = jEnv->GetStringUTFChars (jNamespace, NULL); |
|
CIMNamespaceName cnnNamespace; |
|
bool fNamespaceValid = false; |
|
_nameSpace n; |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
try |
|
{ |
|
cnnNamespace = pszNamespace; |
|
fNamespaceValid = true; |
|
} |
|
catch (Exception e) |
|
{ |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byteArray |
jEnv->ReleaseStringUTFChars (jNamespace, pszNamespace); |
(JNIEnv *jEnv, jobject jThs, jshortArray jshortA, jboolean notSigned) |
|
|
try |
{ | { |
CIMValue *cv = NULL; |
if (ci) |
jboolean b; |
{ |
jsize len = jEnv->GetArrayLength(jshortA); |
cop = new CIMObjectPath (ci->getPath ()); |
jshort *jsA = jEnv->GetShortArrayElements(jshortA,&b); |
|
| |
if (notSigned) { |
if (cop) |
Array<Uint8> u8; |
{ |
for (jsize i=0;i<len;i++) |
if (fNamespaceValid) |
u8.append((Uint8)jsA[i]); |
{ |
cv=new CIMValue(u8); |
cop->setNameSpace (cnnNamespace); |
} | } |
else { |
else |
Array<Sint8> s8; |
{ |
for (jsize i=0;i<len;i++) |
if (cop->getNameSpace ().isNull ()) |
s8.append((Sint8)jsA[i]); |
cop->setNameSpace (n.nameSpace ()); |
cv=new CIMValue(s8); |
|
} | } |
| |
jEnv->ReleaseShortArrayElements(jshortA, jsA, len); |
if (cop->getHost ().size () == 0) |
|
cop->setHost (n.hostName ()); |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
|
} | } |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1shortArray |
|
(JNIEnv *jEnv, jobject jThs, jintArray jintA, jboolean notSigned) |
|
{ |
|
CIMValue *cv = NULL; |
|
jboolean b; |
|
jsize len = jEnv->GetArrayLength(jintA); |
|
jint *jiA = jEnv->GetIntArrayElements(jintA,&b); |
|
|
|
if (notSigned) { |
|
Array<Uint16> u16; |
|
for (jsize i=0;i<len;i++) |
|
u16.append((Uint16)jiA[i]); |
|
cv=new CIMValue(u16); |
|
} | } |
else { |
|
Array<Sint16> s16; |
|
for (jsize i=0;i<len;i++) |
|
s16.append((Sint16)jiA[i]); |
|
cv=new CIMValue(s16); |
|
} | } |
|
Catch (jEnv); |
| |
jEnv->ReleaseIntArrayElements(jintA, jiA, len); |
return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop); |
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
|
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1intArray |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1finalize |
(JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned) |
(JNIEnv *jEnv, jobject jThs, jlong jCop) |
{ | { |
CIMValue *cv = NULL; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
jboolean b; |
|
jsize len = jEnv->GetArrayLength(jlongA); |
|
jlong *jlA = jEnv->GetLongArrayElements(jlongA,&b); |
|
|
|
if (notSigned) { |
|
Array<Uint32> u32; |
|
for (jsize i=0;i<len;i++) |
|
u32.append((Uint32)jlA[i]); |
|
cv=new CIMValue(u32); |
|
} |
|
else { |
|
Array<Sint32> s32; |
|
for (jsize i=0;i<len;i++) |
|
s32.append((Sint32)jlA[i]); |
|
cv=new CIMValue(s32); |
|
} |
|
| |
jEnv->ReleaseLongArrayElements(jlongA, jlA, len); |
delete cop; |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
DEBUG_ConvertCleanup (jlong, jCop); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1longArray |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getNameSpace |
(JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned) |
(JNIEnv *jEnv, jobject jThs, jlong jCop) |
{ | { |
CIMValue *cv = NULL; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
jboolean b; |
const String &ns = cop->getNameSpace ().getString (); |
jsize len = jEnv->GetArrayLength(jlongA); |
|
jlong *jlA = jEnv->GetLongArrayElements(jlongA,&b); |
|
| |
if (notSigned) { |
jstring str = jEnv->NewStringUTF (ns.getCString ()); |
Array<Uint64> u64; |
|
for (jsize i=0;i<len;i++) |
return str; |
u64.append((Uint64)jlA[i]); |
|
cv=new CIMValue(u64); |
|
} |
|
else { |
|
Array<Sint64> s64; |
|
for (jsize i=0;i<len;i++) |
|
s64.append((Sint64)jlA[i]); |
|
cv=new CIMValue(s64); |
|
} | } |
| |
jEnv->ReleaseLongArrayElements(jlongA, jlA, len); |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setNameSpace |
|
(JNIEnv *jEnv, jobject jThs, jlong jCop, jstring jName) |
|
{ |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
const char *str = jEnv->GetStringUTFChars (jName,NULL); |
|
|
|
cop->setNameSpace (CIMNamespaceName (str)); |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
jEnv->ReleaseStringUTFChars (jName,str); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1stringArray |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getHost |
(JNIEnv *jEnv, jobject jThs, jobjectArray jstringA) |
(JNIEnv *jEnv, jobject jThs, jlong jCop) |
{ | { |
CIMValue *cv = NULL; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
jsize len = jEnv->GetArrayLength(jstringA); |
const String &hn = cop->getHost (); |
Array<String> strA; |
|
|
|
for (jsize i=0;i<len;i++) { |
|
jstring jsA = (jstring)jEnv->GetObjectArrayElement(jstringA,i); |
|
const char *str = jEnv->GetStringUTFChars(jsA,NULL); |
|
| |
strA.append(String(str)); |
jstring str = jEnv->NewStringUTF (hn.getCString ()); |
| |
jEnv->ReleaseStringUTFChars(jsA,str); |
return str; |
} | } |
| |
cv = new CIMValue(strA); |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setHost |
|
(JNIEnv *jEnv, jobject jThs, jlong jCop, jstring jName) |
|
{ |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
const char *str = jEnv->GetStringUTFChars (jName,NULL); |
|
|
|
cop->setHost (String (str)); |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
jEnv->ReleaseStringUTFChars (jName,str); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1booleanArray |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getObjectName |
(JNIEnv *jEnv, jobject jThs, jbooleanArray jboolA) |
(JNIEnv *jEnv, jobject jThs, jlong jCop) |
{ | { |
CIMValue *cv = NULL; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
jboolean b; |
const String &cn = cop->getClassName ().getString (); |
jsize len = jEnv->GetArrayLength(jboolA); |
|
jboolean *jbA = jEnv->GetBooleanArrayElements(jboolA,&b); |
|
Array<Boolean> bA; |
|
|
|
for (jsize i=0;i<len;i++) |
|
bA.append((Boolean)jbA[i]); |
|
cv=new CIMValue(bA); |
|
| |
jEnv->ReleaseBooleanArrayElements(jboolA, jbA, len); |
jstring str = jEnv->NewStringUTF (cn.getCString ()); |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
return str; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1floatArray |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setObjectName |
(JNIEnv *jEnv, jobject jThs, jfloatArray jfloatA) |
(JNIEnv *jEnv, jobject jThs, jlong jCop, jstring jName) |
{ | { |
CIMValue *cv = NULL; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
jboolean b; |
const char *str = jEnv->GetStringUTFChars (jName,NULL); |
jsize len = jEnv->GetArrayLength(jfloatA); |
|
jfloat *jfA = jEnv->GetFloatArrayElements(jfloatA,&b); |
|
Array<float> fA; |
|
|
|
for (jsize i=0;i<len;i++) |
|
fA.append((float)jfA[i]); |
|
cv=new CIMValue(fA); |
|
| |
jEnv->ReleaseFloatArrayElements(jfloatA, jfA, len); |
cop->setClassName (String (str)); |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
jEnv->ReleaseStringUTFChars (jName,str); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1doubleArray |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeys |
(JNIEnv *jEnv, jobject jThs, jdoubleArray jdoubleA) |
(JNIEnv *jEnv, jobject jThs, jlong jCop, jobject jVec) |
{ | { |
CIMValue *cv = NULL; |
JMPIjvm::cacheIDs (jEnv); |
jboolean b; |
|
jsize len = jEnv->GetArrayLength(jdoubleA); |
|
jdouble *jdA = jEnv->GetDoubleArrayElements(jdoubleA,&b); |
|
Array<double> dA; |
|
| |
for (jsize i=0;i<len;i++) |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
dA.append((double)jdA[i]); |
const Array<CIMKeyBinding> &akb = cop->getKeyBindings (); |
cv=new CIMValue(dA); |
|
| |
jEnv->ReleaseDoubleArrayElements(jdoubleA, jdA, len); |
for (Uint32 i = 0, s = akb.size (); i < s; i++) |
|
{ |
|
const String &n = akb[i].getName ().getString (); |
|
const String &v = akb[i].getValue (); |
|
CIMKeyBinding::Type t = akb[i].getType (); |
|
CIMValue *cv = 0; |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
switch (t) |
|
{ |
|
case CIMKeyBinding::NUMERIC: |
|
cv = new CIMValue ((Sint32)atol (v.getCString ())); |
|
break; |
|
case CIMKeyBinding::STRING: |
|
cv = new CIMValue (v); |
|
break; |
|
case CIMKeyBinding::BOOLEAN: |
|
cv = new CIMValue ((Boolean) (v.getCString ())); |
|
break; |
|
case CIMKeyBinding::REFERENCE: |
|
cv = new CIMValue (CIMObjectPath (akb[i].getValue ())); |
|
break; |
|
default: |
|
throwCIMException (jEnv,"+++ unsupported type: "); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1copArray |
CIMProperty *cp = 0; |
(JNIEnv *jEnv, jobject jThs, jintArray jintA) |
|
{ |
|
CIMValue *cv = NULL; |
|
jboolean b; |
|
jsize len = jEnv->GetArrayLength(jintA); |
|
jint *jiA = jEnv->GetIntArrayElements(jintA,&b); |
|
Array<CIMObjectPath> cA; |
|
| |
for (jsize i=0;i<len;i++) |
if (t != CIMKeyBinding::REFERENCE) |
cA.append(*((CIMObjectPath*)jiA[i])); |
cp = new CIMProperty (n, *cv); |
cv=new CIMValue(cA); |
else |
|
cp = new CIMProperty( |
|
n, |
|
*cv, |
|
0, |
|
((CIMObjectPath) akb[i].getValue()).getClassName()); |
|
|
|
jlong jCp = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp); |
|
jobject prop = jEnv->NewObject( |
|
JMPIjvm::jv.CIMPropertyClassRef, |
|
JMPIjvm::jv.CIMPropertyNewJ, |
|
jCp); |
| |
jEnv->ReleaseIntArrayElements(jintA, jiA, len); |
jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,prop); |
|
} |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
return jVec; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1datetimeArray |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setKeys |
(JNIEnv *jEnv, jobject jThs, jintArray jintA) |
(JNIEnv *jEnv, jobject jThs, jlong jCop, jobject jVec) |
{ | { |
CIMValue *cv = NULL; |
JMPIjvm::cacheIDs (jEnv); |
jboolean b; |
|
jsize len = jEnv->GetArrayLength(jintA); |
|
jint *jiA = jEnv->GetIntArrayElements(jintA,&b); |
|
Array<CIMDateTime> cA; |
|
| |
for (jsize i=0;i<len;i++) |
CIMObjectPath *cop = DEBUG_ConvertJavaToC(jlong, CIMObjectPath*, jCop); |
cA.append(*((CIMDateTime*)jiA[i])); |
Array<CIMKeyBinding> akb; |
cv=new CIMValue(cA); |
|
| |
jEnv->ReleaseIntArrayElements(jintA, jiA, len); |
for (Uint32 i=0,s=jEnv->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);i<s;i++) |
|
{ |
|
jobject o = jEnv->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,(i)); |
|
jlong jCp = jEnv->CallLongMethod (o,JMPIjvm::jv.CIMPropertyCInst); |
|
CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jCp); |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
akb.append (CIMKeyBinding (cp->getName (), cp->getValue ())); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1objectArray |
cop->setKeyBindings (akb); |
(JNIEnv *jEnv, jobject jThs, jintArray jintA) |
} |
{ |
|
CIMValue *cv = NULL; |
|
jboolean b; |
|
jsize len = jEnv->GetArrayLength(jintA); |
|
jint *jiA = jEnv->GetIntArrayElements(jintA,&b); |
|
Array<CIMObject> cA; |
|
| |
for (jsize i=0;i<len;i++) |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1addKey |
cA.append(*((CIMObject*)jiA[i])); |
(JNIEnv *jEnv, jobject jThs, jlong jCop, jstring jId, jlong jVal) |
cv=new CIMValue(cA); |
{ |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC(jlong, CIMObjectPath*, jCop); |
|
const char *str = jEnv->GetStringUTFChars (jId, NULL); |
|
CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jVal); |
|
Array<CIMKeyBinding> keyBindings = cop->getKeyBindings (); |
| |
jEnv->ReleaseIntArrayElements(jintA, jiA, len); |
keyBindings.append (CIMKeyBinding (str,*cv)); |
|
cop->setKeyBindings (Array<CIMKeyBinding> (keyBindings)); |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
jEnv->ReleaseStringUTFChars (jId, str); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1char16Array |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeyValue |
(JNIEnv *jEnv, jobject jThs, jcharArray jcharA) |
(JNIEnv *jEnv, jobject jThs, jlong jCop, jstring jStr) |
{ | { |
CIMValue *cv = NULL; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
jboolean b; |
const Array<CIMKeyBinding> &akb = cop->getKeyBindings (); |
jsize len = jEnv->GetArrayLength(jcharA); |
const char *strKeyName = jEnv->GetStringUTFChars (jStr,NULL); |
jchar *jcA = jEnv->GetCharArrayElements(jcharA,&b); |
jstring retStr = NULL; |
Array<Char16> cA; |
|
| |
for (jsize i=0;i<len;i++) |
for (Uint32 i = 0,s = akb.size (); i<s; i++) |
cA.append(Char16 (jcA[i])); |
{ |
cv=new CIMValue(cA); |
const String &n = akb[i].getName ().getString (); |
|
|
|
if (n == String (strKeyName)) |
|
{ |
|
retStr = jEnv->NewStringUTF (akb[i].getValue ().getCString ()); |
|
break; |
|
} |
|
} |
| |
jEnv->ReleaseCharArrayElements(jcharA, jcA, len); |
jEnv->ReleaseStringUTFChars (jStr,strKeyName); |
| |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
return retStr; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1toString |
(JNIEnv *jEnv, jobject jThs, jint jP) |
(JNIEnv *jEnv, jobject jThs, jlong jCop) |
{ | { |
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jP); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
bool fSuccess = false; |
const String &ns = cop->toString (); |
int iJType = 0; |
|
| |
iJType = _dataType::convertCTypeToJavaType (cv->getType(), &fSuccess); |
jstring str = jEnv->NewStringUTF (ns.getCString ()); |
| |
return DEBUG_ConvertCToJava (int, jint, iJType); |
return str; |
} | } |
| |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1clone |
(JNIEnv *jEnv, jobject jThs, jint jV) |
(JNIEnv *jEnv, jobject jThs, jlong jCop) |
{ | { |
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
CIMObjectPath *copl = new CIMObjectPath( |
|
cop->getHost(), |
|
cop->getNameSpace(), |
|
cop->getClassName(), |
|
cop->getKeyBindings()); |
| |
return (jstring)jEnv->NewStringUTF(cv->toString().getCString()); |
return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, copl); |
} | } |
| |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMValue__1getValue |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1set |
(JNIEnv *jEnv, jobject jThs, jint jV) |
(JNIEnv *jEnv, jobject jThs, jstring jStr) |
{ | { |
JMPIjvm::cacheIDs(jEnv); |
const char *strCop = jEnv->GetStringUTFChars (jStr,NULL); |
|
CIMObjectPath *cop = new CIMObjectPath (); |
| |
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); |
cop->set (String (strCop)); |
| |
if (cv->isNull ()) |
jEnv->ReleaseStringUTFChars (jStr,strCop); |
return NULL; |
|
| |
CIMType type = cv->getType (); |
return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop); |
|
} |
| |
if (!cv->isArray ()) |
|
{ |
// ------------------------------------- |
switch (type) |
// --- |
|
// - CIMOMHandle |
|
// --- |
|
// ------------------------------------- |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getClass |
|
(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jboolean lo, |
|
jboolean iq, jboolean ic, jobjectArray jPl) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
CIMPropertyList pl; |
|
OperationContext ctx; |
|
|
|
if (jPl) |
|
pl = getList (jEnv, jPl); |
|
else |
|
pl = CIMPropertyList (); |
|
|
|
try { |
|
CIMClass cls = ch->getClass (ctx, |
|
cop->getNameSpace (), |
|
cop->getClassName (), |
|
(Boolean)lo, |
|
(Boolean)iq, |
|
(Boolean)ic, |
|
pl); |
|
|
|
return DEBUG_ConvertCToJava (CIMClass*, jlong, new CIMClass (cls)); |
|
} |
|
Catch(jEnv); |
|
|
|
return 0; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteClass |
|
(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
|
|
try { |
|
ch->deleteClass (ctx, |
|
cop->getNameSpace (), |
|
cop->getClassName ()); |
|
} |
|
Catch(jEnv); |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createClass |
|
(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jlong jCl) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
CIMClass *cl = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCl); |
|
OperationContext ctx; |
|
|
|
try { |
|
ch->createClass (ctx, |
|
cop->getNameSpace (), |
|
*cl); |
|
} |
|
Catch(jEnv); |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setClass |
|
(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jlong jCl) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
CIMClass *cl = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCl); |
|
OperationContext ctx; |
|
|
|
try { |
|
ch->modifyClass (ctx, |
|
cop->getNameSpace (), |
|
*cl); |
|
} |
|
Catch(jEnv); |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClassNames |
|
(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jboolean deep) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
CIMNamespaceName ns = cop->getNameSpace (); |
|
OperationContext ctx; |
|
|
|
try { |
|
Array<CIMName> enm = ch->enumerateClassNames(ctx, |
|
cop->getNameSpace(), |
|
cop->getClassName(), |
|
(Boolean)deep); |
|
Array<CIMObjectPath> *enmop = new Array<CIMObjectPath> (); |
|
|
|
for (int i = 0, m = enm.size (); i < m; i++) |
|
{ |
|
enmop->append (CIMObjectPath (String::EMPTY, |
|
ns, |
|
enm[i])); |
|
} |
|
|
|
return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jlong, enmop); |
|
} |
|
Catch(jEnv); |
|
|
|
return 0; |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClasses |
|
(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jboolean deep, |
|
jboolean lo, jboolean iq, jboolean ic) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
|
|
try { |
|
Array<CIMClass> en = ch->enumerateClasses (ctx, |
|
cop->getNameSpace(), |
|
cop->getClassName(), |
|
(Boolean)deep, |
|
(Boolean)lo, |
|
(Boolean)iq, |
|
(Boolean)ic); |
|
|
|
return DEBUG_ConvertCToJava( |
|
Array<CIMClass>*, |
|
jlong, |
|
new Array<CIMClass> (en)); |
|
} |
|
Catch (jEnv); |
|
|
|
return 0; |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getInstance( |
|
JNIEnv *jEnv, |
|
jobject jThs, |
|
jlong jCh, |
|
jlong jCop, |
|
jboolean lo, |
|
jboolean iq, |
|
jboolean ic, |
|
jobjectArray jPl) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
CIMPropertyList pl; |
|
|
|
if (jPl) |
|
pl = getList (jEnv,jPl); |
|
else |
|
pl = CIMPropertyList (); |
|
|
|
try { |
|
CIMInstance *inst = new CIMInstance(ch->getInstance( |
|
ctx, |
|
cop->getNameSpace(), |
|
*cop, |
|
(Boolean)lo, |
|
(Boolean)iq, |
|
(Boolean)ic, |
|
pl)); |
|
|
|
return DEBUG_ConvertCToJava (CIMInstance*, jlong, inst); |
|
} |
|
Catch (jEnv); |
|
|
|
return 0; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance |
|
(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
|
|
try { |
|
ch->deleteInstance (ctx,cop->getNameSpace (),*cop); |
|
} |
|
Catch (jEnv); |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createInstance |
|
(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jlong jCi) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jCi); |
|
OperationContext ctx; |
|
|
|
try { |
|
ci->setPath (*cop); |
|
|
|
CIMObjectPath obj = ch->createInstance (ctx, |
|
cop->getNameSpace (), |
|
*ci); |
|
|
|
return DEBUG_ConvertCToJava(CIMObjectPath*,jlong,new CIMObjectPath(obj)); |
|
} |
|
Catch (jEnv); |
|
|
|
return 0; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1modifyInstance |
|
(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jlong jCi, |
|
jboolean iq, jobjectArray jPl) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jCi); |
|
CIMPropertyList pl = getList (jEnv, jPl); |
|
OperationContext ctx; |
|
|
|
try { |
|
ci->setPath (*cop); |
|
ch->modifyInstance (ctx, |
|
cop->getNameSpace (), |
|
*ci, |
|
(Boolean)iq, |
|
pl); |
|
} |
|
Catch (jEnv); |
|
} |
|
|
|
JNIEXPORT jlong JNICALL |
|
Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstanceNames( |
|
JNIEnv *jEnv, |
|
jobject jThs, |
|
jlong jCh, |
|
jlong jCop, |
|
jboolean deep) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
|
|
try { |
|
Array<CIMObjectPath> enm = ch->enumerateInstanceNames( |
|
ctx, |
|
cop->getNameSpace(), |
|
cop->getClassName()); |
|
return DEBUG_ConvertCToJava( |
|
Array<CIMObjectPath>*, |
|
jlong, |
|
new Array<CIMObjectPath> (enm)); |
|
} |
|
Catch (jEnv); |
|
|
|
return 0; |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstances |
|
(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jboolean deep, |
|
jboolean lo, jboolean iq, jboolean ic, jobjectArray jPl) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
CIMPropertyList pl; |
|
OperationContext ctx; |
|
|
|
if (jPl) |
|
pl = getList (jEnv, jPl); |
|
else |
|
pl = CIMPropertyList (); |
|
|
|
try { |
|
Array<CIMInstance> en = ch->enumerateInstances (ctx, |
|
cop->getNameSpace (), |
|
cop->getClassName (), |
|
(Boolean)deep, |
|
(Boolean)lo, |
|
(Boolean)iq, |
|
(Boolean)ic, |
|
pl); |
|
|
|
return DEBUG_ConvertCToJava( |
|
Array<CIMInstance>*, |
|
jlong, |
|
new Array<CIMInstance> (en)); |
|
} |
|
Catch (jEnv); |
|
|
|
return 0; |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1execQuery( |
|
JNIEnv *jEnv, |
|
jobject jThs, |
|
jlong jCh, |
|
jlong jCop, |
|
jstring jQuery, |
|
jstring jQl) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
const char *str = jEnv->GetStringUTFChars (jQuery,NULL); |
|
String query (str); |
|
|
|
jEnv->ReleaseStringUTFChars (jQuery,str); |
|
|
|
str = jEnv->GetStringUTFChars (jQl, NULL); |
|
|
|
String ql (str); |
|
|
|
jEnv->ReleaseStringUTFChars (jQl, str); |
|
|
|
try { |
|
Array<CIMObject> enm = ch->execQuery (ctx, |
|
cop->getNameSpace (), |
|
ql, |
|
query); |
|
Array<CIMInstance> *enmInst = new Array<CIMInstance> (); |
|
|
|
for (int i = 0,m = enm.size (); i<m; i++) |
|
{ |
|
enmInst->append (CIMInstance (enm[i])); |
|
} |
|
|
|
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jlong, enmInst); |
|
} |
|
Catch (jEnv); |
|
|
|
return 0; |
|
} |
|
|
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getProperty |
|
(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jstring jN) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
const char *str = jEnv->GetStringUTFChars (jN, NULL); |
|
CIMName prop (str); |
|
|
|
jEnv->ReleaseStringUTFChars (jN, str); |
|
|
|
try { |
|
CIMValue *cv = new CIMValue (ch->getProperty (ctx, |
|
cop->getNameSpace (), |
|
*cop, |
|
prop)); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
|
} |
|
Catch (jEnv); |
|
|
|
return 0; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setProperty |
|
(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jstring jPn, jlong jV) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
CIMValue *val = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV); |
|
const char *str = jEnv->GetStringUTFChars (jPn, NULL); |
|
CIMName pName (str); |
|
|
|
jEnv->ReleaseStringUTFChars (jPn, str); |
|
|
|
try { |
|
ch->setProperty (ctx, |
|
cop->getNameSpace (), |
|
*cop, |
|
pName, |
|
*val); |
|
} |
|
Catch (jEnv); |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associatorNames( |
|
JNIEnv *jEnv, |
|
jobject jThs, |
|
jlong jCh, |
|
jlong jCop, |
|
jstring jAssocClass, |
|
jstring jResultClass, |
|
jstring jRole, |
|
jstring jResultRole) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL); |
|
|
|
CIMName assocClass; |
|
|
|
if ( str |
|
&& *str |
|
) |
|
{ |
|
if (CIMName::legal (str)) |
|
{ |
|
assocClass = str; |
|
} |
|
else |
|
{ |
|
jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef, |
|
JMPIjvm::jv.CIMExceptionNewISt, |
|
(jint)4, // CIM_ERR_INVALID_PARAMETER |
|
jEnv->NewStringUTF( |
|
"Invalid association class name")); |
|
|
|
jEnv->Throw ((jthrowable)ev); |
|
|
|
return 0; |
|
} |
|
} |
|
|
|
jEnv->ReleaseStringUTFChars (jAssocClass, str); |
|
|
|
str = jEnv->GetStringUTFChars (jResultClass, NULL); |
|
|
|
CIMName resultClass; |
|
|
|
if ( str |
|
&& *str |
|
) |
|
{ |
|
if (CIMName::legal (str)) |
|
{ |
|
resultClass = str; |
|
} |
|
else |
|
{ |
|
jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef, |
|
JMPIjvm::jv.CIMExceptionNewISt, |
|
(jint)4, // CIM_ERR_INVALID_PARAMETER |
|
jEnv->NewStringUTF( |
|
"Invalid result class name")); |
|
|
|
jEnv->Throw ((jthrowable)ev); |
|
|
|
return 0; |
|
} |
|
} |
|
|
|
jEnv->ReleaseStringUTFChars (jResultClass, str); |
|
|
|
str = jEnv->GetStringUTFChars (jRole, NULL); |
|
|
|
String role (str); |
|
|
|
jEnv->ReleaseStringUTFChars (jRole, str); |
|
|
|
str = jEnv->GetStringUTFChars (jResultRole, NULL); |
|
|
|
String resultRole (str); |
|
|
|
jEnv->ReleaseStringUTFChars (jResultRole, str); |
|
|
|
try { |
|
Array<CIMObjectPath> enm = ch->associatorNames (ctx, |
|
cop->getNameSpace (), |
|
*cop, |
|
assocClass, |
|
resultClass, |
|
role, |
|
resultRole); |
|
|
|
return DEBUG_ConvertCToJava( |
|
Array<CIMObjectPath>*, |
|
jlong, |
|
new Array<CIMObjectPath> (enm)); |
|
} |
|
Catch (jEnv); |
|
|
|
return 0; |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associators( |
|
JNIEnv *jEnv, |
|
jobject jThs, |
|
jlong jCh, |
|
jlong jCop, |
|
jstring jAssocClass, |
|
jstring jResultClass, |
|
jstring jRole, |
|
jstring jResultRole, |
|
jboolean includeQualifiers, |
|
jboolean includeClassOrigin, |
|
jobjectArray jPl) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
CIMPropertyList pl = getList (jEnv, jPl); |
|
const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL); |
|
CIMName assocClass; |
|
|
|
if ( str |
|
&& *str |
|
) |
|
{ |
|
if (CIMName::legal (str)) |
|
{ |
|
assocClass = str; |
|
} |
|
else |
|
{ |
|
jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef, |
|
JMPIjvm::jv.CIMExceptionNewISt, |
|
(jint)4, // CIM_ERR_INVALID_PARAMETER |
|
jEnv->NewStringUTF( |
|
"Invalid association class name")); |
|
|
|
jEnv->Throw ((jthrowable)ev); |
|
|
|
return 0; |
|
} |
|
} |
|
|
|
jEnv->ReleaseStringUTFChars (jAssocClass, str); |
|
|
|
str = jEnv->GetStringUTFChars (jResultClass, NULL); |
|
|
|
CIMName resultClass; |
|
|
|
if ( str |
|
&& *str |
|
) |
|
{ |
|
if (CIMName::legal (str)) |
|
{ |
|
resultClass = str; |
|
} |
|
else |
|
{ |
|
jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef, |
|
JMPIjvm::jv.CIMExceptionNewISt, |
|
(jint)4, // CIM_ERR_INVALID_PARAMETER |
|
jEnv->NewStringUTF( |
|
"Invalid result class name")); |
|
|
|
jEnv->Throw ((jthrowable)ev); |
|
|
|
return 0; |
|
} |
|
} |
|
|
|
jEnv->ReleaseStringUTFChars (jResultClass, str); |
|
|
|
str = jEnv->GetStringUTFChars (jRole, NULL); |
|
|
|
String role (str); |
|
|
|
jEnv->ReleaseStringUTFChars (jRole, str); |
|
|
|
str = jEnv->GetStringUTFChars (jResultRole, NULL); |
|
|
|
String resultRole (str); |
|
|
|
jEnv->ReleaseStringUTFChars (jResultRole, str); |
|
|
|
try { |
|
Array<CIMObject> enm = ch->associators( |
|
ctx, |
|
cop->getNameSpace(), |
|
*cop, |
|
assocClass, |
|
resultClass, |
|
role, |
|
resultRole, |
|
(Boolean)includeQualifiers, |
|
(Boolean)includeClassOrigin, |
|
pl); |
|
Array<CIMInstance> *enmInst = new Array<CIMInstance> (); |
|
|
|
for (int i = 0, m = enm.size (); i < m; i++) |
|
{ |
|
enmInst->append (CIMInstance (enm[i])); |
|
} |
|
|
|
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jlong, enmInst); |
|
} |
|
Catch (jEnv); |
|
|
|
return 0; |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1referenceNames |
|
(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, |
|
jstring jAssocClass, jstring jRole) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL); |
|
CIMName assocClass; |
|
|
|
if ( str |
|
&& *str |
|
) |
|
{ |
|
if (CIMName::legal (str)) |
|
{ |
|
assocClass = str; |
|
} |
|
else |
|
{ |
|
jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef, |
|
JMPIjvm::jv.CIMExceptionNewISt, |
|
(jint)4, // CIM_ERR_INVALID_PARAMETER |
|
jEnv->NewStringUTF( |
|
"Invalid association class name")); |
|
|
|
jEnv->Throw ((jthrowable)ev); |
|
|
|
return 0; |
|
} |
|
} |
|
|
|
jEnv->ReleaseStringUTFChars (jAssocClass, str); |
|
|
|
str = jEnv->GetStringUTFChars (jRole, NULL); |
|
|
|
String role (str); |
|
|
|
jEnv->ReleaseStringUTFChars (jRole, str); |
|
|
|
try { |
|
Array<CIMObjectPath> enm = ch->referenceNames (ctx, |
|
cop->getNameSpace (), |
|
*cop, |
|
assocClass, |
|
role); |
|
|
|
return DEBUG_ConvertCToJava( |
|
Array<CIMObjectPath>*, |
|
jlong, |
|
new Array<CIMObjectPath> (enm)); |
|
} |
|
Catch (jEnv); |
|
|
|
return 0; |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1references |
|
(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, |
|
jstring jAssocClass, jstring jRole, |
|
jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
CIMPropertyList pl = getList (jEnv, jPl); |
|
const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL); |
|
CIMName assocClass; |
|
|
|
if ( str |
|
&& *str |
|
) |
|
{ |
|
if (CIMName::legal (str)) |
|
{ |
|
assocClass = str; |
|
} |
|
else |
|
{ |
|
jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef, |
|
JMPIjvm::jv.CIMExceptionNewISt, |
|
(jint)4, // CIM_ERR_INVALID_PARAMETER |
|
jEnv->NewStringUTF( |
|
"Invalid association class name")); |
|
|
|
jEnv->Throw ((jthrowable)ev); |
|
|
|
return 0; |
|
} |
|
} |
|
|
|
jEnv->ReleaseStringUTFChars (jAssocClass, str); |
|
|
|
str = jEnv->GetStringUTFChars (jRole, NULL); |
|
|
|
String role (str); |
|
|
|
jEnv->ReleaseStringUTFChars (jRole, str); |
|
|
|
try { |
|
Array<CIMObject> enm = ch->references (ctx, |
|
cop->getNameSpace (), |
|
*cop, |
|
assocClass, |
|
role, |
|
(Boolean)includeQualifiers, |
|
(Boolean)includeClassOrigin, |
|
pl); |
|
Array<CIMInstance> *enmInst = new Array<CIMInstance> (); |
|
|
|
for (int i = 0, m = enm.size (); i < m; i++) |
|
{ |
|
enmInst->append (CIMInstance (enm[i])); |
|
} |
|
|
|
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jlong, enmInst); |
|
} |
|
Catch (jEnv); |
|
|
|
return 0; |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod( |
|
JNIEnv *jEnv, |
|
jobject jThs, |
|
jlong jCh, |
|
jlong jCop, |
|
jstring jMn, |
|
jobject jIn, |
|
jobject jOut) |
|
{ |
|
JMPIjvm::cacheIDs (jEnv); |
|
|
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
const char *str = jEnv->GetStringUTFChars (jMn,NULL); |
|
CIMName method (str); |
|
|
|
jEnv->ReleaseStringUTFChars (jMn,str); |
|
|
|
Array<CIMParamValue> in; |
|
Array<CIMParamValue> out; |
|
|
|
for (int i=0,m=jEnv->CallIntMethod(jIn,JMPIjvm::jv.VectorSize);i<m;i++) |
|
{ |
|
JMPIjvm::checkException (jEnv); |
|
|
|
jobject jProp=jEnv->CallObjectMethod(jIn,JMPIjvm::jv.VectorElementAt,i); |
|
|
|
JMPIjvm::checkException (jEnv); |
|
|
|
jlong jp = jEnv->CallLongMethod(jProp,JMPIjvm::jv.CIMPropertyCInst); |
|
CIMProperty *p = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jp); |
|
|
|
JMPIjvm::checkException (jEnv); |
|
|
|
in.append (CIMParamValue (p->getName ().getString (),p->getValue ())); |
|
} |
|
try { |
|
CIMValue *val = new CIMValue (ch->invokeMethod (ctx, |
|
cop->getNameSpace (), |
|
*cop, |
|
method, |
|
in, |
|
out)); |
|
|
|
for (int i = 0,m = out.size (); i<m; i++) |
|
{ |
|
const CIMParamValue &parm = out[i]; |
|
const CIMValue v = parm.getValue (); |
|
CIMProperty *p = new CIMProperty (parm.getParameterName (), |
|
v, |
|
v.getArraySize ()); |
|
jlong jp = DEBUG_ConvertCToJava (CIMProperty*, jlong, p); |
|
jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef, |
|
JMPIjvm::jv.CIMPropertyNewJ, |
|
jp); |
|
|
|
jEnv->CallVoidMethod (jOut, JMPIjvm::jv.VectorAddElement, prop); |
|
} |
|
return DEBUG_ConvertCToJava (CIMValue*, jlong, val); |
|
} |
|
Catch (jEnv); |
|
|
|
return 0; |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod24 |
|
(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jstring jMn, |
|
jobjectArray jIn, jobjectArray jOut) |
|
|
|
{ |
|
JMPIjvm::cacheIDs (jEnv); |
|
|
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop); |
|
OperationContext ctx; |
|
const char *str = jEnv->GetStringUTFChars (jMn, NULL); |
|
CIMName method (str); |
|
|
|
jEnv->ReleaseStringUTFChars (jMn, str); |
|
|
|
Array<CIMParamValue> in; |
|
Array<CIMParamValue> out; |
|
|
|
if (jIn) |
|
{ |
|
for (int i = 0, m = jEnv->GetArrayLength (jIn); i < m; i++) |
|
{ |
|
JMPIjvm::checkException (jEnv); |
|
|
|
jobject jArg = jEnv->GetObjectArrayElement (jIn,i); |
|
|
|
JMPIjvm::checkException (jEnv); |
|
|
|
jlong jp = jEnv->CallLongMethod (jArg,JMPIjvm::jv.CIMArgumentCInst); |
|
CIMParamValue *p = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jp); |
|
|
|
JMPIjvm::checkException (jEnv); |
|
|
|
in.append (*p); |
|
} |
|
} |
|
try { |
|
CIMValue *val = new CIMValue (ch->invokeMethod (ctx, |
|
cop->getNameSpace (), |
|
*cop, |
|
method, |
|
in, |
|
out)); |
|
|
|
if (jOut) |
{ | { |
case CIMTYPE_BOOLEAN: |
for (int i=0,m=out.size(),o=jEnv->GetArrayLength(jOut);i<m && i<o;i++) |
Boolean bo; |
{ |
cv->get(bo); |
CIMParamValue *parm = new CIMParamValue (out[i]); |
return jEnv->NewObject (JMPIjvm::jv.BooleanClassRef, |
jlong jParm = DEBUG_ConvertCToJava (CIMParamValue*, jlong, parm); |
JMPIjvm::jv.BooleanNewZ, |
|
bo); |
jEnv->SetObjectArrayElement( |
case CIMTYPE_SINT8: |
jOut, |
Sint8 s8; |
i, |
cv->get(s8); |
jEnv->NewObject( |
return jEnv->NewObject (JMPIjvm::jv.ByteClassRef, |
JMPIjvm::jv.CIMArgumentClassRef, |
JMPIjvm::jv.ByteNewB, |
JMPIjvm::jv.CIMArgumentNewJ,jParm)); |
s8); |
} |
case CIMTYPE_UINT8: |
} |
Uint8 u8; |
return DEBUG_ConvertCToJava (CIMValue*, jlong, val); |
cv->get(u8); |
} |
return jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef, |
Catch (jEnv); |
JMPIjvm::jv.UnsignedInt8NewS, |
|
u8); |
return 0; |
case CIMTYPE_SINT16: |
} |
Sint16 s16; |
|
cv->get(s16); |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent( |
return jEnv->NewObject (JMPIjvm::jv.ShortClassRef, |
JNIEnv *jEnv, |
JMPIjvm::jv.ShortNewS, |
jobject jThs, |
s16); |
jlong jCh, |
case CIMTYPE_UINT16: |
jstring jName, |
Uint16 u16; |
jstring jNs, |
cv->get(u16); |
jlong jInd) |
return jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef, |
{ |
JMPIjvm::jv.UnsignedInt16NewI, |
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
u16); |
CIMInstance *ind = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInd); |
case CIMTYPE_SINT32: |
const char *str = jEnv->GetStringUTFChars (jName, NULL); |
Sint32 s32; |
String name (str); |
cv->get(s32); |
|
return jEnv->NewObject (JMPIjvm::jv.IntegerClassRef, |
jEnv->ReleaseStringUTFChars (jName, str); |
JMPIjvm::jv.IntegerNewI, |
|
s32); |
str = jEnv->GetStringUTFChars (jNs, NULL); |
case CIMTYPE_UINT32: |
|
Uint32 u32; |
String ns (str); |
cv->get(u32); |
|
return jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef, |
jEnv->ReleaseStringUTFChars (jNs, str); |
JMPIjvm::jv.UnsignedInt32NewJ, |
|
u32); |
CIMObjectPath ref (ind->getPath ()); |
case CIMTYPE_SINT64: |
|
Sint64 s64; |
ref.setNameSpace (ns); |
cv->get(s64); |
|
return jEnv->NewObject (JMPIjvm::jv.LongClassRef, |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4, |
JMPIjvm::jv.LongNewJ, |
"Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent(): ref = %s", |
s64); |
(const char*)ref.toString().getCString())); |
case CIMTYPE_UINT64: |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4, |
|
"Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent(): ind = %s", |
|
(const char*)ind->getPath().toString().getCString())); |
|
|
|
ind->setPath (ref); |
|
|
|
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4, |
|
"Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent(): ind = %s", |
|
(const char*)ind->getPath().toString().getCString())); |
|
|
|
JMPIProviderManager::indProvRecord *prec = NULL; |
|
String sPathString = ind->getPath ().toString (); |
|
OperationContext *context = NULL; |
|
bool fResult = false; |
|
|
|
{ |
|
AutoMutex lock (JMPIProviderManager::mutexProvTab); |
|
|
|
fResult = JMPIProviderManager::provTab.lookup (name, prec); |
|
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4, |
|
"Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent(): " |
|
"fResult = %d, name = %s", |
|
fResult,(const char*)name.getCString())); |
|
} |
|
|
|
if (fResult) |
|
{ |
|
if (prec->enabled) |
|
{ |
|
try |
|
{ |
|
prec->handler->deliver (*prec->ctx, *ind); |
|
} |
|
Catch (jEnv); |
|
} |
|
} |
|
else |
|
{ |
|
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1, |
|
"Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent(): " |
|
"provider name \"%s\" not found", |
|
(const char*)name.getCString())); |
|
} |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1finalize |
|
(JNIEnv *jEnv, jobject jThs, jlong jCh) |
|
{ |
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh); |
|
|
|
delete ch; |
|
|
|
DEBUG_ConvertCleanup (jlong, jCh); |
|
} |
|
|
|
|
|
// ------------------------------------- |
|
// --- |
|
// - CIMParameter |
|
// --- |
|
// ------------------------------------- |
|
|
|
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMParameter__1getName |
|
(JNIEnv *jEnv, jobject jThs, jlong jCp) |
|
{ |
|
CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp); |
|
jstring rv = 0; |
|
|
|
if (cp) |
|
{ |
|
try |
|
{ |
|
CIMName name = cp->getName (); |
|
|
|
rv = jEnv->NewStringUTF (name.getString ().getCString ()); |
|
} |
|
Catch (jEnv); |
|
} |
|
|
|
return rv; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMParameter__1setName |
|
(JNIEnv *jEnv, jobject jThs, jlong jCp, jstring jName) |
|
{ |
|
CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp); |
|
|
|
if (cp && jName) |
|
{ |
|
try |
|
{ |
|
const char *cstrName = jEnv->GetStringUTFChars (jName, NULL); |
|
|
|
CIMName name (cstrName); |
|
|
|
cp->setName (name); |
|
|
|
jEnv->ReleaseStringUTFChars (jName, cstrName); |
|
} |
|
Catch (jEnv); |
|
} |
|
} |
|
|
|
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMParameter__1isArray |
|
(JNIEnv *jEnv, jobject jThs, jlong jCp) |
|
{ |
|
CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp); |
|
jboolean rv = 0; |
|
|
|
if (cp) |
|
{ |
|
try |
|
{ |
|
rv = cp->isArray (); |
|
} |
|
Catch (jEnv); |
|
} |
|
|
|
return rv; |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMParameter__1getArraySize |
|
(JNIEnv *jEnv, jobject jThs, jlong jCp) |
|
{ |
|
CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp); |
|
jint rv = 0; |
|
|
|
if (cp) |
|
{ |
|
try |
|
{ |
|
rv = cp->getArraySize (); |
|
} |
|
Catch (jEnv); |
|
} |
|
|
|
return rv; |
|
} |
|
|
|
JNIEXPORT jstring JNICALL |
|
Java_org_pegasus_jmpi_CIMParameter__1getReferenceClassName( |
|
JNIEnv *jEnv, |
|
jobject jThs, |
|
jlong jCp) |
|
{ |
|
CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp); |
|
jstring rv = 0; |
|
|
|
if (cp) |
|
{ |
|
try |
|
{ |
|
CIMName name = cp->getReferenceClassName (); |
|
|
|
rv = jEnv->NewStringUTF (name.getString ().getCString ()); |
|
} |
|
Catch (jEnv); |
|
} |
|
|
|
return rv; |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMParameter__1getType |
|
(JNIEnv *jEnv, jobject jThs, jlong jCp) |
|
{ |
|
CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp); |
|
jlong rv = 0; |
|
|
|
if (cp) |
|
{ |
|
try |
|
{ |
|
CIMType ct = cp->getType (); |
|
bool fSuccess = false; |
|
String ref = cp->getReferenceClassName ().getString (); |
|
int iJType = 0; |
|
_dataType *type = 0; |
|
|
|
iJType = _dataType::convertCTypeToJavaType (ct, &fSuccess); |
|
|
|
if (fSuccess) |
|
{ |
|
type = new _dataType (iJType, |
|
cp->getArraySize (), |
|
false, |
|
false, |
|
cp->isArray (), |
|
ref, |
|
true); |
|
|
|
rv = DEBUG_ConvertCToJava (_dataType*, jlong, type); |
|
} |
|
} |
|
Catch (jEnv); |
|
} |
|
|
|
return rv; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMParameter__1finalize |
|
(JNIEnv *jEnv, jobject jThs, jlong jCp) |
|
{ |
|
CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp); |
|
|
|
delete cp; |
|
|
|
DEBUG_ConvertCleanup (jlong, jCp); |
|
} |
|
|
|
|
|
// ------------------------------------- |
|
// --- |
|
// - CIMProperty |
|
// --- |
|
// ------------------------------------- |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1getValue |
|
(JNIEnv *jEnv, jobject jThs, jlong jP) |
|
{ |
|
CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP); |
|
CIMValue *cv = new CIMValue (cp->getValue ()); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
|
} |
|
|
|
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getName |
|
(JNIEnv *jEnv, jobject jThs, jlong jP) |
|
{ |
|
CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP); |
|
const String &n = cp->getName ().getString (); |
|
jstring str = jEnv->NewStringUTF (n.getCString ()); |
|
|
|
return str; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setName |
|
(JNIEnv *jEnv, jobject jThs, jlong jP, jstring jN) |
|
{ |
|
CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP); |
|
const char *str = jEnv->GetStringUTFChars (jN,NULL); |
|
|
|
cp->setName (CIMName (str)); |
|
|
|
jEnv->ReleaseStringUTFChars (jN,str); |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1property |
|
(JNIEnv *jEnv, jobject jThs, jstring jN, jlong jV) |
|
{ |
|
CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV); |
|
const char *str = jEnv->GetStringUTFChars (jN, NULL); |
|
CIMProperty *cp = 0; |
|
jlong jCp = 0; |
|
|
|
try { |
|
if (cv->getType ()!= CIMTYPE_REFERENCE) |
{ | { |
Uint64 u64; |
cp = new CIMProperty (String (str),*cv); |
cv->get(u64); |
|
jobject jBIG = jEnv->CallStaticObjectMethod (JMPIjvm::jv.BigIntegerClassRef, |
|
JMPIjvm::jv.BigIntegerValueOf, |
|
u64); |
|
return jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef, |
|
JMPIjvm::jv.UnsignedInt64NewBi, |
|
jBIG); |
|
} | } |
case CIMTYPE_REAL32: |
else |
float f; |
|
cv->get(f); |
|
return jEnv->NewObject (JMPIjvm::jv.FloatClassRef, |
|
JMPIjvm::jv.FloatNewF, |
|
f); |
|
case CIMTYPE_REAL64: |
|
double d; |
|
cv->get(d); |
|
return jEnv->NewObject (JMPIjvm::jv.DoubleClassRef, |
|
JMPIjvm::jv.DoubleNewD, |
|
d); |
|
case CIMTYPE_STRING: |
|
{ | { |
String s; |
if (!cv->isArray ()) |
cv->get(s); |
{ |
return jEnv->NewStringUTF(s.getCString()); |
CIMObjectPath cop; |
|
|
|
cv->get (cop); |
|
cp = new CIMProperty (String (str),*cv,0, cop.getClassName ()); |
} | } |
case CIMTYPE_REFERENCE: |
else |
{ | { |
CIMObjectPath ref; |
throwCIMException( |
cv->get(ref); |
jEnv, |
jint jOp = DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(ref)); |
"+++ unsupported type in CIMProperty.property"); |
return jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef, |
|
JMPIjvm::jv.CIMObjectPathNewI, |
|
jOp); |
|
} | } |
case CIMTYPE_CHAR16: |
} |
|
|
|
jCp = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp); |
|
} |
|
Catch (jEnv); |
|
|
|
jEnv->ReleaseStringUTFChars (jN, str); |
|
|
|
return jCp; |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1new |
|
(JNIEnv *jEnv, jobject jThs, jstring jN, jlong jV) |
{ | { |
Char16 c16; |
CIMProperty *p = new CIMProperty (CIMName (),CIMValue ()); |
cv->get(c16); |
|
return jEnv->NewObject (JMPIjvm::jv.CharacterClassRef, |
return DEBUG_ConvertCToJava (CIMProperty*, jlong, p); |
JMPIjvm::jv.CharacterNewC, |
|
(jchar)c16); |
|
} | } |
case CIMTYPE_DATETIME: |
|
|
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isReference |
|
(JNIEnv *jEnv, jobject jThs, jlong jP) |
{ | { |
CIMDateTime dt; |
CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP); |
cv->get(dt); |
|
jint jDT = DEBUG_ConvertCToJava (CIMDateTime*, jint, new CIMDateTime(dt)); |
return (jboolean) (cp->getType () == CIMTYPE_REFERENCE); |
return jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef, |
|
JMPIjvm::jv.CIMDateTimeNewI, |
|
jDT); |
|
} | } |
case CIMTYPE_OBJECT: |
|
|
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getRefClassName |
|
(JNIEnv *jEnv, jobject jThs, jlong jP) |
{ | { |
CIMObject co; |
CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP); |
cv->get(co); |
const String &n = cp->getReferenceClassName ().getString (); |
if (co.isClass ()) |
|
|
jstring str = jEnv->NewStringUTF (n.getCString ()); |
|
|
|
return str; |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1getType |
|
(JNIEnv *jEnv, jobject jThs, jlong jP) |
{ | { |
jint jCC = DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass(co)); |
CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP); |
|
String ref = cp->getReferenceClassName ().getString (); |
|
bool fSuccess = false; |
|
int iJType = 0; |
|
_dataType *type = 0; |
| |
return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef, |
iJType = _dataType::convertCTypeToJavaType (cp->getType (), &fSuccess); |
JMPIjvm::jv.CIMObjectNewIZ, |
|
jCC, |
if (fSuccess) |
(jboolean)true); |
{ |
|
type = new _dataType (iJType, |
|
cp->getArraySize (), |
|
ref.size () ? true : false, |
|
false, |
|
cp->isArray (), |
|
ref, |
|
true); |
} | } |
else |
|
|
return DEBUG_ConvertCToJava (_dataType*, jlong, type); |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1setType |
|
(JNIEnv *jEnv, jobject jThs, jlong jP, jlong jDt) |
{ | { |
jint jCI = DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance(co)); |
CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP); |
|
_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt); |
|
CIMValue val; |
|
bool fSuccess = false; |
|
CIMType cType = CIMTYPE_BOOLEAN; |
| |
return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef, |
cType = _dataType::convertJavaTypeToCType (dt->_type, &fSuccess); |
JMPIjvm::jv.CIMObjectNewIZ, |
|
jCI, |
if (fSuccess) |
(jboolean)false); |
{ |
|
val.setNullValue (cType, dt->_array); |
|
|
|
CIMProperty *np = new CIMProperty (cp->getName (), val); |
|
|
|
delete cp; |
|
|
|
DEBUG_ConvertCleanup (jlong, jP); |
|
|
|
return DEBUG_ConvertCToJava (CIMProperty*, jlong, np); |
} | } |
|
else |
|
{ |
|
return DEBUG_ConvertCToJava (CIMProperty*, jlong, cp); |
} | } |
default: |
|
throwCIMException(jEnv,"+++ unsupported type: "); |
|
} | } |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setValue |
|
(JNIEnv *jEnv, jobject jThs, jlong jP,jlong jV) |
|
{ |
|
CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP); |
|
CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV); |
|
|
|
cp->setValue (*cv); |
} | } |
else |
|
|
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isArray |
|
(JNIEnv *jEnv, jobject jThs, jlong jP) |
{ | { |
switch (type) |
CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP); |
|
|
|
return (jboolean)cp->isArray (); |
|
} |
|
|
|
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getIdentifier |
|
(JNIEnv *jEnv, jobject jThs, jlong jP) |
{ | { |
case CIMTYPE_BOOLEAN: |
CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP); |
|
const String &n = cp->getName ().getString (); |
|
jstring str = jEnv->NewStringUTF (n.getCString ()); |
|
|
|
return str; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addValue |
|
(JNIEnv *jEnv, jobject jThs, jlong jP, jlong jV) |
{ | { |
Array<Boolean> bo; |
CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP); |
|
CIMValue *cvin = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV); |
|
CIMValue cv = cp->getValue (); |
| |
cv->get(bo); |
if (cvin->isNull ()) |
|
throwCIMException (jEnv,"+++ null cvin value "); |
|
if (!cv.isArray ()) |
|
throwCIMException (jEnv,"+++ not an array "); |
|
if (cvin->getType ()!= cv.getType ()) |
|
throwCIMException (jEnv,"+++ type mismatch "); |
| |
int s = bo.size(); |
CIMType type = cv.getType (); |
jobjectArray jbooleanA = (jobjectArray)jEnv->NewObjectArray (s, |
|
JMPIjvm::jv.BooleanClassRef, |
|
0); |
|
| |
for (int i=0; i < s; i++) |
switch (type) |
jEnv->SetObjectArrayElement(jbooleanA, |
{ |
i, |
case CIMTYPE_BOOLEAN: |
jEnv->NewObject (JMPIjvm::jv.BooleanClassRef, |
{ |
JMPIjvm::jv.BooleanNewZ, |
Boolean bo; |
bo[i])); |
cvin->get (bo); |
return jbooleanA; |
Array<Boolean> boarr; |
|
cv.get (boarr); |
|
boarr.append (bo); |
|
cv.set (boarr); |
|
break; |
|
} |
|
case CIMTYPE_UINT8: |
|
{ |
|
Uint8 u8; |
|
cvin->get (u8); |
|
Array<Uint8> u8arr; |
|
cv.get (u8arr); |
|
u8arr.append (u8); |
|
cv.set (u8arr); |
|
break; |
|
} |
|
case CIMTYPE_SINT8: |
|
{ |
|
Sint8 s8; |
|
cvin->get (s8); |
|
Array<Sint8> s8arr; |
|
cv.get (s8arr); |
|
s8arr.append (s8); |
|
cv.set (s8arr); |
|
break; |
|
} |
|
case CIMTYPE_UINT16: |
|
{ |
|
Uint16 u16; |
|
cvin->get (u16); |
|
Array<Uint16> u16arr; |
|
cv.get (u16arr); |
|
u16arr.append (u16); |
|
cv.set (u16arr); |
|
break; |
|
} |
|
case CIMTYPE_SINT16: |
|
{ |
|
Sint16 s16; |
|
cvin->get (s16); |
|
Array<Sint16> s16arr; |
|
cv.get (s16arr); |
|
s16arr.append (s16); |
|
cv.set (s16arr); |
|
break; |
|
} |
|
case CIMTYPE_UINT32: |
|
{ |
|
Uint32 u32; |
|
cvin->get (u32); |
|
Array<Uint32> u32arr; |
|
cv.get (u32arr); |
|
u32arr.append (u32); |
|
cv.set (u32arr); |
|
break; |
|
} |
|
case CIMTYPE_SINT32: |
|
{ |
|
Sint32 s32; |
|
cvin->get (s32); |
|
Array<Sint32> s32arr; |
|
cv.get (s32arr); |
|
s32arr.append (s32); |
|
cv.set (s32arr); |
|
break; |
|
} |
|
case CIMTYPE_UINT64: |
|
{ |
|
Uint64 u64; |
|
cvin->get (u64); |
|
Array<Uint64> u64arr; |
|
cv.get (u64arr); |
|
u64arr.append (u64); |
|
cv.set (u64arr); |
|
break; |
|
} |
|
case CIMTYPE_SINT64: |
|
{ |
|
Sint64 s64; |
|
cvin->get (s64); |
|
Array<Sint64> s64arr; |
|
cv.get (s64arr); |
|
s64arr.append (s64); |
|
cv.set (s64arr); |
|
break; |
|
} |
|
case CIMTYPE_REAL32: |
|
{ |
|
Real32 f; |
|
cvin->get (f); |
|
Array<Real32> farr; |
|
cv.get (farr); |
|
farr.append (f); |
|
cv.set (farr); |
|
break; |
|
} |
|
case CIMTYPE_REAL64: |
|
{ |
|
Real64 d; |
|
cvin->get (d); |
|
Array<Real64> darr; |
|
cv.get (darr); |
|
darr.append (d); |
|
cv.set (darr); |
|
break; |
} | } |
case CIMTYPE_SINT8: |
case CIMTYPE_CHAR16: |
{ | { |
Array<Sint8> s8; |
Char16 c16; |
|
cvin->get (c16); |
cv->get(s8); |
Array<Char16> c16arr; |
|
cv.get (c16arr); |
int s = s8.size(); |
c16arr.append (c16); |
jobjectArray jbyteA = (jobjectArray)jEnv->NewObjectArray (s, |
cv.set (c16arr); |
JMPIjvm::jv.ByteClassRef, |
break; |
0); |
|
|
|
for (int i=0; i < s; i++) |
|
jEnv->SetObjectArrayElement (jbyteA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.ByteClassRef, |
|
JMPIjvm::jv.ByteNewB, |
|
s8[i])); |
|
return jbyteA; |
|
} | } |
case CIMTYPE_UINT8: |
case CIMTYPE_STRING: |
{ | { |
Array<Uint8> u8; |
String str; |
|
cvin->get (str); |
cv->get(u8); |
Array<String> strarr; |
|
cv.get (strarr); |
int s = u8.size(); |
strarr.append (str); |
jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray (s, |
cv.set (strarr); |
JMPIjvm::jv.UnsignedInt8ClassRef, |
break; |
0); |
|
for (int i=0; i < s; i++) |
|
jEnv->SetObjectArrayElement (jshortA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef, |
|
JMPIjvm::jv.UnsignedInt8NewS, |
|
u8[i])); |
|
return jshortA; |
|
} | } |
case CIMTYPE_SINT16: |
case CIMTYPE_DATETIME: |
{ | { |
Array<Sint16> s16; |
CIMDateTime dt; |
|
cvin->get (dt); |
cv->get(s16); |
Array<CIMDateTime> dtarr; |
|
cv.get (dtarr); |
int s = s16.size(); |
dtarr.append (dt); |
jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray (s, |
cv.set (dtarr); |
JMPIjvm::jv.ShortClassRef, |
break; |
0); |
|
|
|
for (int i=0; i < s; i++) |
|
jEnv->SetObjectArrayElement (jshortA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.ShortClassRef, |
|
JMPIjvm::jv.ShortNewS, |
|
s16[i])); |
|
return jshortA; |
|
} | } |
case CIMTYPE_UINT16: |
case CIMTYPE_REFERENCE: |
{ | { |
Array<Uint16> u16; |
CIMObjectPath ref; |
|
cvin->get (ref); |
cv->get(u16); |
Array<CIMObjectPath> refarr; |
|
cv.get (refarr); |
int s = u16.size(); |
refarr.append (ref); |
jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray (s, |
cv.set (refarr); |
JMPIjvm::jv.UnsignedInt16ClassRef, |
break; |
0); |
|
|
|
for (int i=0; i < s; i++) |
|
jEnv->SetObjectArrayElement (jintA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef, |
|
JMPIjvm::jv.UnsignedInt16NewI, |
|
u16[i])); |
|
return jintA; |
|
} | } |
case CIMTYPE_SINT32: |
case CIMTYPE_OBJECT: |
{ | { |
Array<Sint32> s32; |
CIMObject obj; |
|
cvin->get (obj); |
cv->get(s32); |
Array<CIMObject> objarr; |
|
cv.get (objarr); |
int s = s32.size(); |
objarr.append (obj); |
jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray (s, |
cv.set (objarr); |
JMPIjvm::jv.IntegerClassRef, |
break; |
0); |
|
|
|
for (int i=0; i < s; i++) |
|
jEnv->SetObjectArrayElement (jintA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.IntegerClassRef, |
|
JMPIjvm::jv.IntegerNewI, |
|
s32[i])); |
|
return jintA; |
|
} | } |
case CIMTYPE_UINT32: |
default: |
{ | { |
Array<Uint32> u32; |
throwCIMException (jEnv,"+++ unsupported type "); |
|
} |
|
} |
| |
cv->get(u32); |
cp->setValue (cv); |
|
} |
| |
int s = u32.size(); |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addQualifier |
jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray (s, |
(JNIEnv *jEnv, jobject jThs, jlong jP, jlong jQ) |
JMPIjvm::jv.UnsignedInt32ClassRef, |
{ |
0); |
CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP); |
|
CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ); |
| |
for (int i=0; i < s; i++) |
cp->addQualifier (*cq); |
jEnv->SetObjectArrayElement (jlongA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef, |
|
JMPIjvm::jv.UnsignedInt32NewJ, |
|
u32[i])); |
|
return jlongA; |
|
} | } |
case CIMTYPE_SINT64: |
|
{ |
|
Array<Sint64> s64; |
|
| |
cv->get(s64); |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1finalize |
|
(JNIEnv *jEnv, jobject jThs, jlong jP) |
|
{ |
|
CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP); |
| |
int s = s64.size(); |
delete cp; |
jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray (s, |
|
JMPIjvm::jv.LongClassRef, |
|
0); |
|
| |
for (int i=0; i < s; i++) |
DEBUG_ConvertCleanup (jlong, jP); |
jEnv->SetObjectArrayElement (jlongA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.LongClassRef, |
|
JMPIjvm::jv.LongNewJ, |
|
s64[i])); |
|
return jlongA; |
|
} | } |
case CIMTYPE_UINT64: |
|
{ |
|
Array<Uint64> u64; |
|
|
|
cv->get(u64); |
|
| |
int s = u64.size(); |
/* |
jobjectArray ju64A = (jobjectArray)jEnv->NewObjectArray (s, |
* Class: org_pegasus_jmpi_CIMProperty |
JMPIjvm::jv.UnsignedInt64ClassRef, |
* Method: _findQualifier |
0); |
* Signature: (Ljava/lang/String;)I |
|
*/ |
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1findQualifier |
|
(JNIEnv *jEnv, jobject jThs, jlong jP, jstring jQualifier) |
|
{ |
|
CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP); |
|
const char *str = jEnv->GetStringUTFChars (jQualifier, NULL); |
|
Uint32 index = PEG_NOT_FOUND; |
| |
for (int i=0; i < s; i++) |
try |
{ | { |
jobject jBIG = jEnv->CallStaticObjectMethod (JMPIjvm::jv.BigIntegerClassRef, |
index = cp->findQualifier (CIMName (str)); |
JMPIjvm::jv.BigIntegerValueOf, |
|
u64[i]); |
|
| |
jEnv->SetObjectArrayElement (ju64A, |
jEnv->ReleaseStringUTFChars (jQualifier, str); |
i, |
|
jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef, |
|
JMPIjvm::jv.UnsignedInt64NewBi, |
|
jBIG)); |
|
} | } |
return ju64A; |
Catch (jEnv); |
|
|
|
return index; |
} | } |
case CIMTYPE_REAL32: |
|
{ |
|
Array<Real32> r32; |
|
| |
cv->get(r32); |
/* |
|
* Class: org_pegasus_jmpi_CIMProperty |
|
* Method: _getQualifier |
|
* Signature: (I)I |
|
*/ |
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1getQualifier |
|
(JNIEnv *jEnv, jobject jThs, jlong jP, jint jIndex) |
|
{ |
|
CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP); |
|
CIMQualifier *cq = NULL; |
|
CIMQualifier qualifier; |
| |
int s = r32.size(); |
try |
jobjectArray jfloatA = (jobjectArray)jEnv->NewObjectArray (s, |
{ |
JMPIjvm::jv.FloatClassRef, |
qualifier = cp->getQualifier ((Uint32)jIndex); |
0); |
cq = new CIMQualifier (qualifier); |
|
} |
|
Catch (jEnv); |
| |
for (int i=0; i < s; i++) |
return DEBUG_ConvertCToJava (CIMQualifier *, jlong, cq); |
jEnv->SetObjectArrayElement (jfloatA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.FloatClassRef, |
|
JMPIjvm::jv.FloatNewF, |
|
r32[i])); |
|
return jfloatA; |
|
} | } |
case CIMTYPE_REAL64: |
|
{ |
|
Array<Real64> r64; |
|
| |
cv->get(r64); |
|
| |
int s = r64.size(); |
// ------------------------------------- |
jobjectArray jdoubleA = (jobjectArray)jEnv->NewObjectArray (s, |
// --- |
JMPIjvm::jv.DoubleClassRef, |
// - CIMQualifier |
0); |
// --- |
|
// ------------------------------------- |
| |
for (int i=0; i < s; i++) |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMQualifier__1new |
jEnv->SetObjectArrayElement (jdoubleA, |
(JNIEnv *jEnv, jobject jThs, jstring jN) |
i, |
|
jEnv->NewObject (JMPIjvm::jv.DoubleClassRef, |
|
JMPIjvm::jv.DoubleNewD, |
|
r64[i])); |
|
return jdoubleA; |
|
} |
|
case CIMTYPE_STRING: |
|
{ | { |
Array<String> str; |
const char *str = jEnv->GetStringUTFChars (jN,NULL); |
|
CIMQualifier *qual = new CIMQualifier (CIMName (str),CIMValue ()); |
cv->get(str); |
|
| |
int s = str.size(); |
jEnv->ReleaseStringUTFChars (jN,str); |
jobjectArray jstringA = (jobjectArray)jEnv->NewObjectArray (s, |
|
JMPIjvm::jv.StringClassRef, |
|
0); |
|
| |
for (int i=0; i < s; i++) |
return DEBUG_ConvertCToJava (CIMQualifier*, jlong, qual); |
jEnv->SetObjectArrayElement (jstringA, |
|
i, |
|
jEnv->NewStringUTF (str[i].getCString())); |
|
return jstringA; |
|
} | } |
case CIMTYPE_REFERENCE: |
|
{ |
|
Array<CIMObjectPath> ref; |
|
| |
cv->get(ref); |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getName |
|
(JNIEnv *jEnv, jobject jThs, jlong jQ) |
|
{ |
|
CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ); |
|
const String &n = cq->getName ().getString (); |
|
jstring str = jEnv->NewStringUTF (n.getCString ()); |
| |
int s = ref.size(); |
return str; |
jobjectArray jrefA = (jobjectArray)jEnv->NewObjectArray (s, |
} |
JMPIjvm::jv.CIMObjectPathClassRef, |
|
0); |
|
| |
for (int i=0; i < s; i++) |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getValue |
|
(JNIEnv *jEnv, jobject jThs, jlong jQ) |
{ | { |
jint jOP = DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(ref[i])); |
CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ); |
|
CIMValue *cv = new CIMValue (cq->getValue ()); |
| |
jEnv->SetObjectArrayElement (jrefA, |
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
i, |
|
jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef, |
|
JMPIjvm::jv.CIMObjectPathNewI, |
|
jOP)); |
|
} |
|
return jrefA; |
|
} | } |
case CIMTYPE_CHAR16: |
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1setValue |
|
(JNIEnv *jEnv, jobject jThs, jlong jQ,jlong jV) |
{ | { |
Array<Char16> c16; |
CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ); |
|
CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV); |
| |
cv->get(c16); |
cq->setValue (*cv); |
|
} |
| |
int s = c16.size(); |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1finalize |
jobjectArray jc16A = (jobjectArray)jEnv->NewObjectArray (s, |
(JNIEnv *jEnv, jobject jThs, jlong jQ) |
JMPIjvm::jv.CharacterClassRef, |
{ |
0); |
CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ); |
| |
for (int i=0; i < s; i++) |
delete cq; |
jEnv->SetObjectArrayElement (jc16A, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.CharacterClassRef, |
|
JMPIjvm::jv.CharacterNewC, |
|
(jchar)c16[i])); |
|
| |
return jc16A; |
DEBUG_ConvertCleanup (jlong, jQ); |
} | } |
case CIMTYPE_DATETIME: |
|
{ |
|
Array<CIMDateTime> dt; |
|
| |
cv->get(dt); |
|
| |
int s = dt.size(); |
// ------------------------------------- |
jobjectArray jdtA = (jobjectArray)jEnv->NewObjectArray (s, |
// --- |
JMPIjvm::jv.CIMDateTimeClassRef, |
// - CIMQualifierType |
0); |
// --- |
|
// ------------------------------------- |
| |
for (int i=0; i < s; i++) |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1new |
|
(JNIEnv *jEnv, jobject jThs) |
{ | { |
jint jDT = DEBUG_ConvertCToJava (CIMDateTime*, jint, new CIMDateTime(dt[i])); |
CIMQualifierDecl *qual = new CIMQualifierDecl (); |
| |
jEnv->SetObjectArrayElement (jdtA, |
return DEBUG_ConvertCToJava (CIMQualifierDecl*, jlong, qual); |
i, |
|
jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef, |
|
JMPIjvm::jv.CIMDateTimeNewI, |
|
jDT)); |
|
} |
|
return jdtA; |
|
} | } |
case CIMTYPE_OBJECT: |
|
{ |
|
Array<CIMObject> co; |
|
| |
cv->get(co); |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1getName |
|
(JNIEnv *jEnv, jobject jThs, jlong jQ) |
|
{ |
|
CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jlong, CIMQualifierDecl*, jQ); |
|
const String &n = qt->getName ().getString (); |
|
jstring str = jEnv->NewStringUTF (n.getCString ()); |
| |
int s = co.size(); |
return str; |
jobjectArray jcoA = (jobjectArray)jEnv->NewObjectArray (s, |
} |
JMPIjvm::jv.CIMObjectClassRef, |
|
0); |
|
| |
for (int i=0; i < s; i++) |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setName |
|
(JNIEnv *jEnv, jobject jThs, jlong jQ, jstring jN) |
{ | { |
if (co[i].isClass ()) |
CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jlong, CIMQualifierDecl*, jQ); |
|
const char *str = jEnv->GetStringUTFChars (jN, NULL); |
|
jlong jret = 0; |
|
|
|
if (qt->isUninitialized ()) |
{ | { |
jint jCC = DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass(co[i])); |
CIMQualifierDecl *nqt = new CIMQualifierDecl( |
|
CIMName(str), |
|
CIMValue(), |
|
CIMScope()); |
| |
jEnv->SetObjectArrayElement (jcoA, |
jret = DEBUG_ConvertCToJava (CIMQualifierDecl*, jlong, nqt); |
i, |
|
jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef, |
|
JMPIjvm::jv.CIMObjectNewIZ, |
|
jCC, |
|
(jboolean)true)); |
|
} | } |
else | else |
{ | { |
jint jCI = DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance(co[i])); |
qt->setName (CIMName (str)); |
| |
jEnv->SetObjectArrayElement (jcoA, |
CIMQualifierDecl *nqt = new CIMQualifierDecl (*qt); |
i, |
|
jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef, |
jret = DEBUG_ConvertCToJava (CIMQualifierDecl*, jlong, nqt); |
JMPIjvm::jv.CIMObjectNewIZ, |
|
jCI, |
|
(jboolean)false)); |
|
} |
|
} |
|
return jcoA; |
|
} |
|
default: |
|
throwCIMException(jEnv,"+++ unsupported type: "); |
|
} | } |
|
|
|
jEnv->ReleaseStringUTFChars (jN, str); |
|
|
|
return jret; |
} | } |
| |
return NULL; |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setValue |
|
(JNIEnv *jEnv, jobject jThs, jlong jQ,jlong jV) |
|
{ |
|
CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jlong, CIMQualifierDecl*, jQ); |
|
CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV); |
|
|
|
qt->setValue (*cv); |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMValue__1finalize |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1finalize |
(JNIEnv *jEnv, jobject jThs, jint jV) |
(JNIEnv *jEnv, jobject jThs, jlong jQ) |
{ | { |
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); |
CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jlong, CIMQualifierDecl*, jQ); |
| |
delete cv; |
delete qt; |
| |
DEBUG_ConvertCleanup (jint, jV); |
DEBUG_ConvertCleanup (jlong, jQ); |
} | } |
| |
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
// - CIMNameSpace |
// - CIMValue |
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
_nameSpace::_nameSpace() { |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1byte |
port_=0; |
(JNIEnv *jEnv, jobject jThs, jbyte jb, jboolean notSigned) |
hostName_=System::getHostName(); |
{ |
nameSpace_="root/cimv2"; |
CIMValue *cv = NULL; |
|
|
|
if (notSigned) |
|
cv = new CIMValue ((Uint8)jb); |
|
else |
|
cv = new CIMValue ((Sint8)jb); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
| |
_nameSpace::_nameSpace(String hn) { |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1short |
port_=0; |
(JNIEnv *jEnv, jobject jThs, jshort js, jboolean notSigned) |
hostName_=hn; |
{ |
nameSpace_="root/cimv2"; |
CIMValue *cv = NULL; |
|
|
|
if (notSigned) |
|
cv = new CIMValue ((Uint16)js); |
|
else |
|
cv = new CIMValue( (Sint16)js); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
| |
_nameSpace::_nameSpace(String hn, String ns) { |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1makeInt |
port_=0; |
(JNIEnv *jEnv, jobject jThs, jlong ji, jboolean notSigned) |
hostName_=hn; |
{ |
nameSpace_=ns; |
CIMValue *cv = NULL; |
|
|
|
if (notSigned) |
|
cv = new CIMValue ((Uint32)ji); |
|
else |
|
cv = new CIMValue ((Sint32)ji); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
| |
int _nameSpace::port() { |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1long |
if (port_) return port_; |
(JNIEnv *jEnv, jobject jThs, jlong jl, jboolean notSigned) |
port_=5988; |
{ |
if (hostName_.subString(0,7)=="http://") { |
CIMValue *cv = NULL; |
protocol_="http://"; |
|
hostName_=hostName_.subString(7); |
if (notSigned) |
|
cv = new CIMValue ((Uint64)jl); |
|
else |
|
cv = new CIMValue ((Sint64)jl); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
Sint32 p=hostName_.reverseFind(':'); |
|
if (p>=0) { |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1string |
if ((hostName_[p+1] >= '0') && (hostName_[p+1] <= '9')) |
(JNIEnv *jEnv, jobject jThs, jstring jS) |
port_=atoi(hostName_.subString(p+1).getCString()); |
{ |
hostName_.remove(p); |
const char *str = jEnv->GetStringUTFChars (jS,NULL); |
|
CIMValue *cv = new CIMValue (String (str)); |
|
|
|
jEnv->ReleaseStringUTFChars (jS,str); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
return port_; |
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1boolean |
|
(JNIEnv *jEnv, jobject jThs, jboolean jB) |
|
{ |
|
CIMValue *cv = new CIMValue ((Boolean)jB); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
| |
String _nameSpace::hostName() { |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1float |
port(); |
(JNIEnv *jEnv, jobject jThs, jfloat jF) |
return hostName_; |
{ |
|
CIMValue *cv = new CIMValue (jF); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
| |
String _nameSpace::nameSpace() { |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1double |
return nameSpace_; |
(JNIEnv *jEnv, jobject jThs, jdouble jD) |
|
{ |
|
CIMValue *cv = new CIMValue (jD); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
| |
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1cop |
|
(JNIEnv *jEnv, jobject jThs, jlong jR) |
|
{ |
|
CIMObjectPath *ref = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jR); |
|
CIMValue *cv = new CIMValue (*ref); |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1new |
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
(JNIEnv *jEnv, jobject jThs) |
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1datetime |
|
(JNIEnv *jEnv, jobject jThs, jlong jDT) |
{ | { |
return DEBUG_ConvertCToJava (_nameSpace*, jint, new _nameSpace()); |
CIMDateTime *dt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jDT); |
|
CIMValue *cv = new CIMValue (*dt); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHn |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1char16 |
(JNIEnv *jEnv, jobject jThs, jstring jHn) |
(JNIEnv *jEnv, jobject jThs, jchar jChar16) |
{ | { |
const char *hn = jEnv->GetStringUTFChars(jHn,NULL); |
Char16 c16 (jChar16); |
jint cInst = DEBUG_ConvertCToJava (_nameSpace*, jint, new _nameSpace(hn)); |
CIMValue *cv = new CIMValue (c16); |
| |
jEnv->ReleaseStringUTFChars(jHn,hn); |
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
|
} |
| |
return cInst; |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1object |
|
(JNIEnv *jEnv, jobject jThs, jlong jO) |
|
{ |
|
CIMObject *co = DEBUG_ConvertJavaToC (jlong, CIMObject*, jO); |
|
CIMValue *cv = new CIMValue (*co); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHnNs |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1byteArray |
(JNIEnv *jEnv, jobject jThs, jstring jHn, jstring jNs) |
(JNIEnv *jEnv, jobject jThs, jshortArray jshortA, jboolean notSigned) |
{ | { |
const char *hn = jEnv->GetStringUTFChars(jHn,NULL); |
CIMValue *cv = NULL; |
const char *ns = jEnv->GetStringUTFChars(jNs,NULL); |
jboolean b; |
jint cInst = DEBUG_ConvertCToJava (_nameSpace*, jint, new _nameSpace(String(hn),String(ns))); |
jsize len = jEnv->GetArrayLength (jshortA); |
|
jshort *jsA = jEnv->GetShortArrayElements (jshortA, &b); |
| |
jEnv->ReleaseStringUTFChars(jHn,hn); |
if (notSigned) |
jEnv->ReleaseStringUTFChars(jNs,ns); |
{ |
|
Array<Uint8> u8; |
| |
return cInst; |
for (jsize i = 0; i < len; i++) |
} |
u8.append ((Uint8)jsA[i]); |
| |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getHost |
cv = new CIMValue (u8); |
(JNIEnv *jEnv, jobject jThs, jint jNs) |
} |
|
else |
{ | { |
_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs); |
Array<Sint8> s8; |
const String &hn = cNs->hostName_; |
|
jstring str = jEnv->NewStringUTF(hn.getCString()); |
|
| |
return str; |
for (jsize i = 0; i < len; i++) |
|
s8.append ((Sint8)jsA[i]); |
|
|
|
cv = new CIMValue (s8); |
} | } |
| |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getNameSpace |
jEnv->ReleaseShortArrayElements (jshortA, jsA, 0); |
(JNIEnv *jEnv, jobject jThs, jint jNs) |
|
{ |
|
_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs); |
|
const String &ns = cNs->nameSpace_; |
|
jstring str = jEnv->NewStringUTF(ns.getCString()); |
|
| |
return str; |
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setHost |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1shortArray |
(JNIEnv *jEnv, jobject jThs, jint jNs, jstring jHn) |
(JNIEnv *jEnv, jobject jThs, jintArray jintA, jboolean notSigned) |
{ | { |
_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs); |
CIMValue *cv = NULL; |
const char *str = jEnv->GetStringUTFChars(jHn,NULL); |
jboolean b; |
|
jsize len = jEnv->GetArrayLength (jintA); |
|
jint *jiA = jEnv->GetIntArrayElements (jintA, &b); |
| |
cNs->port_=0; |
if (notSigned) |
cNs->hostName_=str; |
{ |
|
Array<Uint16> u16; |
| |
jEnv->ReleaseStringUTFChars(jHn,str); |
for (jsize i = 0; i < len; i++) |
} |
u16.append ((Uint16)jiA[i]); |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setNameSpace |
cv = new CIMValue (u16); |
(JNIEnv *jEnv, jobject jThs, jint jNs, jstring jN) |
} |
|
else |
{ | { |
_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs); |
Array<Sint16> s16; |
const char *str = jEnv->GetStringUTFChars(jN,NULL); |
|
| |
cNs->nameSpace_=str; |
for (jsize i = 0; i < len; i++) |
|
s16.append ((Sint16)jiA[i]); |
| |
jEnv->ReleaseStringUTFChars(jN,str); |
cv = new CIMValue (s16); |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1finalize |
jEnv->ReleaseIntArrayElements (jintA, jiA, 0); |
(JNIEnv *jEnv, jobject jThs, jint jNs) |
|
|
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
|
} |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1intArray |
|
(JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned) |
{ | { |
_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs); |
CIMValue *cv = NULL; |
|
jboolean b; |
|
jsize len = jEnv->GetArrayLength (jlongA); |
|
jlong *jlA = jEnv->GetLongArrayElements (jlongA, &b); |
| |
delete cNs; |
if (notSigned) |
|
{ |
|
Array<Uint32> u32; |
| |
DEBUG_ConvertCleanup (jint, jNs); |
for (jsize i = 0; i < len; i++) |
|
u32.append ((Uint32)jlA[i]); |
|
|
|
cv = new CIMValue (u32); |
} | } |
|
else |
|
{ |
|
Array<Sint32> s32; |
| |
// ------------------------------------- |
for (jsize i = 0; i < len; i++) |
// --- |
s32.append ((Sint32)jlA[i]); |
// - Enumerators |
|
// --- |
|
// ------------------------------------- |
|
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1getClass |
cv = new CIMValue (s32); |
(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) |
} |
{ |
|
Array<CIMClass> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMClass>*, jEnum); |
|
| |
return DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass((*enm)[pos])); |
jEnv->ReleaseLongArrayElements (jlongA, jlA, 0); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1size |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1longArray |
(JNIEnv *jEnv, jobject jThs, jint jEnum) |
(JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned) |
|
{ |
|
CIMValue *cv = NULL; |
|
jboolean b; |
|
jsize len = jEnv->GetArrayLength (jlongA); |
|
jlong *jlA = jEnv->GetLongArrayElements (jlongA, &b); |
|
|
|
if (notSigned) |
{ | { |
Array<CIMClass> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMClass>*, jEnum); |
Array<Uint64> u64; |
|
|
return enm->size(); |
|
} |
|
| |
|
for (jsize i = 0; i < len; i++) |
|
u64.append ((Uint64)jlA[i]); |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1getInstance |
cv = new CIMValue (u64); |
(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) |
} |
|
else |
{ | { |
Array<CIMInstance> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMInstance>*, jEnum); |
Array<Sint64> s64; |
| |
return DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance((*enm)[pos])); |
for (jsize i = 0; i < len; i++) |
|
s64.append ((Sint64)jlA[i]); |
|
|
|
cv = new CIMValue (s64); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1size |
jEnv->ReleaseLongArrayElements (jlongA, jlA, 0); |
(JNIEnv *jEnv, jobject jThs, jint jEnum) |
|
{ |
|
Array<CIMInstance> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMInstance>*, jEnum); |
|
| |
return enm->size(); |
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1getObjectPath |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1stringArray |
(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) |
(JNIEnv *jEnv, jobject jThs, jobjectArray jstringA) |
{ | { |
Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMObjectPath>*, jEnum); |
CIMValue *cv = NULL; |
|
jsize len = jEnv->GetArrayLength (jstringA); |
return DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath((*enm)[pos])); |
Array<String> strA; |
} |
|
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1size |
for (jsize i = 0;i < len; i++) |
(JNIEnv *jEnv, jobject jThs, jint jEnum) |
|
{ | { |
Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMObjectPath>*, jEnum); |
jstring jsA = (jstring)jEnv->GetObjectArrayElement (jstringA, i); |
|
const char *str = jEnv->GetStringUTFChars (jsA, NULL); |
| |
return enm->size(); |
strA.append (String (str)); |
|
|
|
jEnv->ReleaseStringUTFChars (jsA, str); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1getQualifierType |
cv = new CIMValue (strA); |
(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) |
|
{ |
|
Array<CIMQualifierDecl> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMQualifierDecl>*, jEnum); |
|
| |
return DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, new CIMQualifierDecl((*enm)[pos])); |
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1size |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1booleanArray |
(JNIEnv *jEnv, jobject jThs, jint jEnum) |
(JNIEnv *jEnv, jobject jThs, jbooleanArray jboolA) |
{ | { |
Array<CIMQualifierDecl> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMQualifierDecl>*, jEnum); |
CIMValue *cv = NULL; |
|
jboolean b; |
|
jsize len = jEnv->GetArrayLength (jboolA); |
|
jboolean *jbA = jEnv->GetBooleanArrayElements (jboolA, &b); |
|
Array<Boolean> bA; |
| |
return enm->size(); |
for (jsize i = 0; i < len; i++) |
} |
bA.append ((Boolean)jbA[i]); |
| |
// ------------------------------------- |
cv = new CIMValue (bA); |
// --- |
|
// - CIMClient |
|
// --- |
|
// ------------------------------------- |
|
| |
void checkNs(CIMObjectPath *cop, jint jNs) { |
jEnv->ReleaseBooleanArrayElements (jboolA, jbA, 0); |
if (cop->getNameSpace().isNull()) { |
|
_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs); |
|
| |
cop->setNameSpace(CIMNamespaceName(cNs->nameSpace())); |
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} |
|
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1newNaUnPw |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1floatArray |
(JNIEnv *jEnv, jobject jThs, jint jNs, jstring jUn, jstring jPw) |
(JNIEnv *jEnv, jobject jThs, jfloatArray jfloatA) |
{ | { |
_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs); |
CIMValue *cv = NULL; |
const char *un = jEnv->GetStringUTFChars(jUn,NULL); |
jboolean b; |
const char *pw = jEnv->GetStringUTFChars(jPw,NULL); |
jsize len = jEnv->GetArrayLength (jfloatA); |
jint jCc = 0; |
jfloat *jfA = jEnv->GetFloatArrayElements (jfloatA, &b); |
|
Array<float> fA; |
try { |
|
CIMClient *cc=new CIMClient(); |
|
| |
cc->connect(cNs->hostName(),cNs->port(),un,pw); |
for (jsize i = 0; i< len; i++) |
|
fA.append ((float)jfA[i]); |
| |
jCc = DEBUG_ConvertCToJava (CIMClient*, jint, cc); |
cv = new CIMValue (fA); |
} |
|
Catch(jEnv); |
|
| |
jEnv->ReleaseStringUTFChars(jUn,un); |
jEnv->ReleaseFloatArrayElements (jfloatA, jfA, 0); |
jEnv->ReleaseStringUTFChars(jPw,pw); |
|
| |
return jCc; |
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1disconnect |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1doubleArray |
(JNIEnv *jEnv, jobject jThs, jint jCc) |
(JNIEnv *jEnv, jobject jThs, jdoubleArray jdoubleA) |
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
CIMValue *cv = NULL; |
|
jboolean b; |
|
jsize len = jEnv->GetArrayLength (jdoubleA); |
|
jdouble *jdA = jEnv->GetDoubleArrayElements (jdoubleA, &b); |
|
Array<double> dA; |
| |
try { |
for (jsize i = 0; i < len; i++) |
cCc->disconnect(); |
dA.append ((double)jdA[i]); |
} |
|
Catch(jEnv); |
|
} |
|
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getClass |
cv = new CIMValue (dA); |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean lo, |
|
jboolean iq, jboolean ic, jobjectArray jPl) |
|
{ |
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
CIMPropertyList pl=getList(jEnv,jPl); |
|
| |
try { |
jEnv->ReleaseDoubleArrayElements (jdoubleA, jdA, 0); |
checkNs(cop,jNs); |
|
CIMClass cls=cCc->getClass(cop->getNameSpace(),cop->getClassName(),(Boolean)lo, |
|
(Boolean)iq,(Boolean)ic,pl); |
|
return DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass(cls)); |
|
} |
|
Catch(jEnv); |
|
| |
return 0; |
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteClass |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1copArray |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop) |
(JNIEnv *jEnv, jobject jThs, jlongArray jlongA) |
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
CIMValue *cv = NULL; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
jboolean b; |
|
jsize len = jEnv->GetArrayLength (jlongA); |
|
jlong *jiA = jEnv->GetLongArrayElements (jlongA, &b); |
|
Array<CIMObjectPath> cA; |
| |
try { |
for (jsize i = 0; i < len; i++) |
checkNs(cop,jNs); |
{ |
cCc->deleteClass(cop->getNameSpace(),cop->getClassName()); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jiA[i]); |
} |
cA.append (*cop); |
Catch(jEnv); |
|
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createClass |
cv = new CIMValue (cA); |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, int jCl) |
|
{ |
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
CIMClass *cl = DEBUG_ConvertJavaToC (jint, CIMClass*, jCl); |
|
| |
try { |
jEnv->ReleaseLongArrayElements (jlongA, jiA, 0); |
cCc->createClass(cop->getNameSpace(),*cl); |
|
} |
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
Catch(jEnv); |
|
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setClass |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1datetimeArray |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jCl) |
(JNIEnv *jEnv, jobject jThs, jlongArray jlongA) |
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
CIMValue *cv = NULL; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
jboolean b; |
CIMClass *cl = DEBUG_ConvertJavaToC (jint, CIMClass*, jCl); |
jsize len = jEnv->GetArrayLength (jlongA); |
|
jlong *jiA = jEnv->GetLongArrayElements (jlongA, &b); |
|
Array<CIMDateTime> cA; |
| |
try { |
for (jsize i = 0; i < len; i++) |
checkNs(cop,jNs); |
{ |
cCc->modifyClass(cop->getNameSpace(),*cl); |
CIMDateTime *cdt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jiA[i]); |
} |
cA.append (*cdt); |
Catch(jEnv); |
|
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClasses |
cv = new CIMValue (cA); |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, int jCop, jboolean deep, jboolean lo, jboolean iq, jboolean ic) |
|
{ |
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
| |
try { |
jEnv->ReleaseLongArrayElements (jlongA, jiA, 0); |
checkNs(cop,jNs); |
|
Array<CIMClass> enm=cCc->enumerateClasses( |
|
cop->getNameSpace(),cop->getClassName(),(Boolean)deep,(Boolean)lo,(Boolean)iq,(Boolean)ic); |
|
return DEBUG_ConvertCToJava (Array<CIMClass>*, jint, new Array<CIMClass>(enm)); |
|
} |
|
Catch(jEnv); |
|
| |
return 0; |
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClassNames |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1objectArray |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep) |
(JNIEnv *jEnv, jobject jThs, jlongArray jlongA) |
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
CIMValue *cv = NULL; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
jboolean b; |
CIMNamespaceName ns = cop->getNameSpace(); |
jsize len = jEnv->GetArrayLength (jlongA); |
|
jlong *jiA = jEnv->GetLongArrayElements (jlongA, &b); |
|
Array<CIMObject> cA; |
| |
try { |
for (jsize i = 0; i < len; i++) |
checkNs(cop,jNs); |
{ |
Array<CIMName> enm=cCc->enumerateClassNames(ns,cop->getClassName(),(Boolean)deep); |
CIMObject *co = DEBUG_ConvertJavaToC (jlong, CIMObject*, jiA[i]); |
Array<CIMObjectPath> *enmop=new Array<CIMObjectPath>(); |
cA.append (*co); |
for (int i=0,m=enm.size(); i<m; i++) { |
|
enmop->append(CIMObjectPath(String::EMPTY,ns,enm[i])); |
|
} |
|
return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, enmop); |
|
} | } |
Catch(jEnv); |
|
| |
return 0; |
cv = new CIMValue (cA); |
|
|
|
jEnv->ReleaseLongArrayElements (jlongA, jiA, 0); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateQualifiers |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1char16Array |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, int jCop) |
(JNIEnv *jEnv, jobject jThs, jcharArray jcharA) |
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
CIMValue *cv = NULL; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
jboolean b; |
|
jsize len = jEnv->GetArrayLength (jcharA); |
|
jchar *jcA = jEnv->GetCharArrayElements (jcharA, &b); |
|
Array<Char16> cA; |
| |
try { |
for (jsize i = 0; i < len; i++) |
checkNs(cop,jNs); |
cA.append (Char16 (jcA[i])); |
| |
Array<CIMQualifierDecl> enm=cCc->enumerateQualifiers(cop->getNameSpace()); |
cv = new CIMValue (cA); |
| |
return DEBUG_ConvertCToJava (Array<CIMQualifierDecl>*, jint, new Array<CIMQualifierDecl>(enm)); |
jEnv->ReleaseCharArrayElements (jcharA, jcA, 0); |
} |
|
Catch(jEnv); |
|
| |
return 0; |
return DEBUG_ConvertCToJava (CIMValue*, jlong, cv); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getInstance |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMValue__1getValue |
(JNIEnv *jEnv, jobject jThs, jint jCc, int jNs, int jCop, jboolean lo, |
(JNIEnv *jEnv, jobject jThs, jlong jV) |
jboolean iq, jboolean ic, jobjectArray jPl) |
|
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
JMPIjvm::cacheIDs (jEnv); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
CIMPropertyList pl = getList(jEnv,jPl); |
|
| |
try { |
CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV); |
checkNs(cop,jNs); |
|
| |
CIMInstance inst=cCc->getInstance(cop->getNameSpace(), |
if (cv->isNull ()) |
*cop, |
return NULL; |
(Boolean)lo, |
|
(Boolean)iq, |
|
(Boolean)ic, |
|
pl); |
|
| |
return DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance(inst)); |
CIMType type = cv->getType (); |
} |
|
Catch(jEnv); |
|
| |
return 0; |
if (!cv->isArray ()) |
|
{ |
|
switch (type) |
|
{ |
|
case CIMTYPE_BOOLEAN: |
|
{ |
|
Boolean bo; |
|
cv->get (bo); |
|
return jEnv->NewObject (JMPIjvm::jv.BooleanClassRef, |
|
JMPIjvm::jv.BooleanNewZ, |
|
(jboolean)bo); |
} | } |
|
case CIMTYPE_SINT8: |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteInstance |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop) |
|
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
Sint8 s8; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
cv->get (s8); |
|
return jEnv->NewObject (JMPIjvm::jv.ByteClassRef, |
try { |
JMPIjvm::jv.ByteNewB, |
checkNs(cop,jNs); |
(jbyte)s8); |
cCc->deleteInstance(cop->getNameSpace(),*cop); |
|
} | } |
Catch(jEnv); |
case CIMTYPE_UINT8: |
|
{ |
|
Uint8 u8; |
|
cv->get (u8); |
|
return jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef, |
|
JMPIjvm::jv.UnsignedInt8NewS, |
|
(jshort)u8); |
} | } |
|
case CIMTYPE_SINT16: |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1createInstance |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, int jCi) |
|
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
Sint16 s16; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
cv->get (s16); |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi); |
return jEnv->NewObject (JMPIjvm::jv.ShortClassRef, |
|
JMPIjvm::jv.ShortNewS, |
try { |
(jshort)s16); |
checkNs(cop,jNs); |
|
ci->setPath(*cop); |
|
CIMObjectPath obj=cCc->createInstance(cop->getNameSpace(),*ci); |
|
return DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(obj)); |
|
} | } |
Catch(jEnv); |
case CIMTYPE_UINT16: |
|
{ |
|
Uint16 u16; |
|
cv->get (u16); |
|
return jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef, |
|
JMPIjvm::jv.UnsignedInt16NewI, |
|
(jint)u16); |
|
} |
|
case CIMTYPE_SINT32: |
|
{ |
|
Sint32 s32; |
|
cv->get (s32); |
|
return jEnv->NewObject (JMPIjvm::jv.IntegerClassRef, |
|
JMPIjvm::jv.IntegerNewI, |
|
(jint)s32); |
|
} |
|
case CIMTYPE_UINT32: |
|
{ |
|
Uint32 u32; |
|
cv->get (u32); |
|
return jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef, |
|
JMPIjvm::jv.UnsignedInt32NewJ, |
|
(jlong)u32); |
|
} |
|
case CIMTYPE_SINT64: |
|
{ |
|
Sint64 s64; |
|
cv->get (s64); |
|
return jEnv->NewObject (JMPIjvm::jv.LongClassRef, |
|
JMPIjvm::jv.LongNewJ, |
|
(jlong)s64); |
|
} |
|
case CIMTYPE_UINT64: |
|
{ |
|
Uint64 u64; |
| |
return 0; |
cv->get (u64); |
} |
|
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1modifyInstance |
std::ostringstream oss; |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jCi, |
jstring jString = 0; |
jboolean iq, jobjectArray jPl) |
jobject jBIG = 0; |
{ |
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi); |
|
CIMPropertyList pl = getList(jEnv,jPl); |
|
| |
try { |
oss << u64 << ends; |
checkNs(cop,jNs); |
|
ci->setPath(*cop); |
|
cCc->modifyInstance(cop->getNameSpace(),*ci,(Boolean)iq,pl); |
|
} |
|
Catch(jEnv); |
|
} |
|
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstances |
jString = jEnv->NewStringUTF (oss.str ().c_str ()); |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep, jboolean lo, |
|
jboolean iq, jboolean ic, jobjectArray jPl) |
|
{ |
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
CIMPropertyList pl = getList(jEnv,jPl); |
|
| |
try { |
if (jString) |
checkNs(cop,jNs); |
{ |
CIMPropertyList props; |
jBIG = jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef, |
Array<CIMInstance> enm=cCc->enumerateInstances( |
JMPIjvm::jv.UnsignedInt64NewStr, |
cop->getNameSpace(),cop->getClassName(),(Boolean)deep,(Boolean)lo,(Boolean)iq,(Boolean)ic,pl); |
jString); |
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, new Array<CIMInstance>(enm)); |
|
} | } |
Catch(jEnv); |
|
| |
return 0; |
return jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef, |
|
JMPIjvm::jv.UnsignedInt64NewBi, |
|
jBIG); |
} | } |
|
case CIMTYPE_REAL32: |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstanceNames |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep) |
|
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
float f; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
cv->get (f); |
|
return jEnv->NewObject (JMPIjvm::jv.FloatClassRef, |
try { |
JMPIjvm::jv.FloatNewF, |
checkNs(cop,jNs); |
(jfloat)f); |
Array<CIMObjectPath> enm=cCc->enumerateInstanceNames( |
|
cop->getNameSpace(),cop->getClassName()); //,(Boolean)deep); |
|
return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm)); |
|
} | } |
Catch(jEnv); |
case CIMTYPE_REAL64: |
|
{ |
return 0; |
double d; |
|
cv->get (d); |
|
return jEnv->NewObject (JMPIjvm::jv.DoubleClassRef, |
|
JMPIjvm::jv.DoubleNewD, |
|
(jdouble)d); |
} | } |
|
case CIMTYPE_STRING: |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getQualifier |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop) |
|
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
String s; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
cv->get (s); |
|
return jEnv->NewStringUTF (s.getCString ()); |
try { |
|
checkNs(cop,jNs); |
|
CIMQualifierDecl *val=new CIMQualifierDecl(cCc->getQualifier(cop->getNameSpace(),cop->getClassName())); |
|
return DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, val); |
|
} | } |
Catch(jEnv); |
case CIMTYPE_REFERENCE: |
|
{ |
return 0; |
CIMObjectPath ref; |
|
cv->get (ref); |
|
jlong jOp = DEBUG_ConvertCToJava( |
|
CIMObjectPath*, |
|
jlong, |
|
new CIMObjectPath (ref)); |
|
return jEnv->NewObject( |
|
JMPIjvm::jv.CIMObjectPathClassRef, |
|
JMPIjvm::jv.CIMObjectPathNewJ, |
|
jOp); |
} | } |
|
case CIMTYPE_CHAR16: |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteQualifier |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop) |
|
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
Char16 c16; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
cv->get (c16); |
|
return jEnv->NewObject (JMPIjvm::jv.CharacterClassRef, |
try { |
JMPIjvm::jv.CharacterNewC, |
checkNs(cop,jNs); |
(jchar)c16); |
cCc->deleteQualifier(cop->getNameSpace(),cop->getClassName()); |
|
} | } |
Catch(jEnv); |
case CIMTYPE_DATETIME: |
|
{ |
|
CIMDateTime dt; |
|
cv->get (dt); |
|
jlong jDT = DEBUG_ConvertCToJava( |
|
CIMDateTime*, jlong, |
|
new CIMDateTime(dt)); |
|
return jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef, |
|
JMPIjvm::jv.CIMDateTimeNewJ, |
|
jDT); |
} | } |
|
case CIMTYPE_OBJECT: |
|
{ |
|
CIMObject co; |
|
cv->get (co); |
|
if (co.isClass ()) |
|
{ |
|
jlong jCC = DEBUG_ConvertCToJava( |
|
CIMClass*, |
|
jlong, |
|
new CIMClass (co)); |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setQualifier |
return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef, |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jQ) |
JMPIjvm::jv.CIMObjectNewJZ, |
|
jCC, |
|
(jboolean)true); |
|
} |
|
else |
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
jlong jCI = DEBUG_ConvertCToJava( |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
CIMInstance*, |
CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ); |
jlong, |
|
new CIMInstance (co)); |
| |
try { |
return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef, |
checkNs(cop,jNs); |
JMPIjvm::jv.CIMObjectNewJZ, |
cCc->setQualifier(cop->getNameSpace(),*qt); |
jCI, |
|
(jboolean)false); |
} | } |
Catch(jEnv); |
|
} | } |
|
default: |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty |
throwCIMException (jEnv,"+++ unsupported type: "); |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn) |
} |
|
} |
|
else |
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
switch (type) |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
{ |
const char *str = jEnv->GetStringUTFChars(jPn,NULL); |
case CIMTYPE_BOOLEAN: |
CIMName pName(str); |
{ |
jint jCv = 0; |
Array<Boolean> bo; |
| |
try { |
cv->get (bo); |
checkNs(cop,jNs); |
|
| |
CIMValue *val = new CIMValue(cCc->getProperty(cop->getNameSpace(),*cop,pName)); |
int s = bo.size (); |
|
jobjectArray jbooleanA = (jobjectArray)jEnv->NewObjectArray( |
|
s, |
|
JMPIjvm::jv.BooleanClassRef, |
|
0); |
| |
jCv = DEBUG_ConvertCToJava (CIMValue*, jint, val); |
for (int i = 0; i < s; i++) |
|
{ |
|
jEnv->SetObjectArrayElement( |
|
jbooleanA, |
|
i, |
|
jEnv->NewObject( |
|
JMPIjvm::jv.BooleanClassRef, |
|
JMPIjvm::jv.BooleanNewZ, |
|
(jboolean)bo[i])); |
} | } |
Catch(jEnv); |
return jbooleanA; |
|
} |
|
case CIMTYPE_SINT8: |
|
{ |
|
Array<Sint8> s8; |
| |
jEnv->ReleaseStringUTFChars(jPn,str); |
cv->get (s8); |
| |
return jCv; |
int s = s8.size (); |
} |
jobjectArray jbyteA = (jobjectArray)jEnv->NewObjectArray( |
|
s, |
|
JMPIjvm::jv.ByteClassRef, |
|
0); |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty |
for (int i = 0; i < s; i++) |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn, jint jV) |
|
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
jEnv->SetObjectArrayElement( |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
jbyteA, |
CIMValue *val = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); |
i, |
const char *str = jEnv->GetStringUTFChars(jPn,NULL); |
jEnv->NewObject( |
CIMName pName(str); |
JMPIjvm::jv.ByteClassRef, |
|
JMPIjvm::jv.ByteNewB, |
try { |
(jbyte)s8[i])); |
checkNs(cop,jNs); |
|
cCc->setProperty(cop->getNameSpace(),*cop,pName,*val); |
|
} | } |
Catch(jEnv); |
return jbyteA; |
|
|
jEnv->ReleaseStringUTFChars(jPn,str); |
|
} | } |
|
case CIMTYPE_UINT8: |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn, jobject jIn, jobject jOut) |
|
{ | { |
JMPIjvm::cacheIDs(jEnv); |
Array<Uint8> u8; |
|
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
const char *str = jEnv->GetStringUTFChars(jMn,NULL); |
|
CIMName method(str); |
|
jint jCv = 0; |
|
Array<CIMParamValue> in; |
|
Array<CIMParamValue> out; |
|
|
|
for (int i=0,m=jEnv->CallIntMethod(jIn,JMPIjvm::jv.VectorSize); i<m; i++) { |
|
JMPIjvm::checkException(jEnv); |
|
|
|
jobject jProp=jEnv->CallObjectMethod(jIn,JMPIjvm::jv.VectorElementAt,i); |
|
JMPIjvm::checkException(jEnv); |
|
|
|
jint jp = jEnv->CallIntMethod(jProp,JMPIjvm::jv.CIMPropertyCInst); |
|
CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp); |
|
| |
JMPIjvm::checkException(jEnv); |
cv->get (u8); |
| |
in.append(CIMParamValue(p->getName().getString(),p->getValue())); |
int s = u8.size (); |
|
jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray( |
|
s, |
|
JMPIjvm::jv.UnsignedInt8ClassRef, |
|
0); |
|
for (int i = 0; i < s; i++) |
|
{ |
|
jEnv->SetObjectArrayElement( |
|
jshortA, |
|
i, |
|
jEnv->NewObject( |
|
JMPIjvm::jv.UnsignedInt8ClassRef, |
|
JMPIjvm::jv.UnsignedInt8NewS, |
|
(jshort)u8[i])); |
} | } |
|
return jshortA; |
try { |
|
checkNs(cop,jNs); |
|
|
|
CIMValue *val = new CIMValue(cCc->invokeMethod(cop->getNameSpace(),*cop,method,in,out)); |
|
|
|
for (int i=0,m=out.size(); i<m; i++) { |
|
const CIMParamValue &parm = out[i]; |
|
const CIMValue v = parm.getValue(); |
|
CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize()); |
|
jint jp = DEBUG_ConvertCToJava (CIMProperty*, jint, p); |
|
jobject prop = jEnv->NewObject(JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jp); |
|
|
|
jEnv->CallVoidMethod(jOut,JMPIjvm::jv.VectorAddElement,prop); |
|
} | } |
|
case CIMTYPE_SINT16: |
|
{ |
|
Array<Sint16> s16; |
| |
jCv = DEBUG_ConvertCToJava (CIMValue*, jint, val); |
cv->get (s16); |
} |
|
Catch(jEnv); |
|
| |
jEnv->ReleaseStringUTFChars(jMn,str); |
int s = s16.size (); |
|
jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray( |
|
s, |
|
JMPIjvm::jv.ShortClassRef, |
|
0); |
| |
return jCv; |
for (int i = 0; i < s; i++) |
|
{ |
|
jEnv->SetObjectArrayElement( |
|
jshortA, |
|
i, |
|
jEnv->NewObject( |
|
JMPIjvm::jv.ShortClassRef, |
|
JMPIjvm::jv.ShortNewS, |
|
(jshort)s16[i])); |
} | } |
|
return jshortA; |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod24 |
} |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn, |
case CIMTYPE_UINT16: |
jobjectArray jIn, jobjectArray jOut) |
|
{ | { |
JMPIjvm::cacheIDs(jEnv); |
Array<Uint16> u16; |
| |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
cv->get (u16); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
const char *str = jEnv->GetStringUTFChars(jMn,NULL); |
|
CIMName method(str); |
|
jint jCv = 0; |
|
Array<CIMParamValue> in; |
|
Array<CIMParamValue> out; |
|
| |
for (int i=0,m=jEnv->GetArrayLength(jIn); i<m; i++) { |
int s = u16.size (); |
JMPIjvm::checkException(jEnv); |
jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray( |
|
s, |
|
JMPIjvm::jv.UnsignedInt16ClassRef, |
|
0); |
| |
jobject jArg=jEnv->GetObjectArrayElement(jIn,i); |
for (int i = 0; i < s; i++) |
JMPIjvm::checkException(jEnv); |
{ |
|
jEnv->SetObjectArrayElement( |
|
jintA, |
|
i, |
|
jEnv->NewObject( |
|
JMPIjvm::jv.UnsignedInt16ClassRef, |
|
JMPIjvm::jv.UnsignedInt16NewI, |
|
(jint)u16[i])); |
|
} |
|
return jintA; |
|
} |
|
case CIMTYPE_SINT32: |
|
{ |
|
Array<Sint32> s32; |
| |
jint jp = jEnv->CallIntMethod(jArg,JMPIjvm::jv.CIMArgumentCInst); |
cv->get (s32); |
CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jp); |
|
| |
JMPIjvm::checkException(jEnv); |
int s = s32.size (); |
|
jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray( |
|
s, |
|
JMPIjvm::jv.IntegerClassRef, |
|
0); |
| |
in.append(*p); |
for (int i = 0; i < s; i++) |
|
{ |
|
jEnv->SetObjectArrayElement( |
|
jintA, |
|
i, |
|
jEnv->NewObject( |
|
JMPIjvm::jv.IntegerClassRef, |
|
JMPIjvm::jv.IntegerNewI, |
|
(jint)s32[i])); |
} | } |
try { |
return jintA; |
checkNs(cop,jNs); |
} |
CIMValue *val=new CIMValue(cCc->invokeMethod(cop->getNameSpace(),*cop,method,in,out)); |
case CIMTYPE_UINT32: |
|
{ |
for (int i=0,m=out.size(),o=jEnv->GetArrayLength(jOut); i<m && i<o; i++) { |
Array<Uint32> u32; |
CIMParamValue *parm = new CIMParamValue (out[i]); |
cv->get (u32); |
jint jParm = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm); |
int s = u32.size (); |
|
jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray( |
|
s, |
|
JMPIjvm::jv.UnsignedInt32ClassRef, |
|
0); |
| |
jEnv->SetObjectArrayElement(jOut, |
for (int i = 0; i < s; i++) |
|
{ |
|
jEnv->SetObjectArrayElement( |
|
jlongA, |
i, | i, |
jEnv->NewObject(JMPIjvm::jv.CIMArgumentClassRef,JMPIjvm::jv.CIMArgumentNewI,jParm)); |
jEnv->NewObject( |
|
JMPIjvm::jv.UnsignedInt32ClassRef, |
|
JMPIjvm::jv.UnsignedInt32NewJ, |
|
(jlong)u32[i])); |
} | } |
jCv = DEBUG_ConvertCToJava (CIMValue*, jint, val); |
return jlongA; |
} | } |
Catch(jEnv); |
case CIMTYPE_SINT64: |
|
{ |
|
Array<Sint64> s64; |
| |
jEnv->ReleaseStringUTFChars(jMn,str); |
cv->get (s64); |
| |
return jCv; |
int s = s64.size (); |
} |
jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray( |
|
s, |
|
JMPIjvm::jv.LongClassRef, |
|
0); |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery |
for (int i = 0; i < s; i++) |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jQuery, jstring jQl) |
|
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
jEnv->SetObjectArrayElement( |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
jlongA, |
const char *str = jEnv->GetStringUTFChars(jQuery,NULL); |
i, |
String query(str); |
jEnv->NewObject( |
|
JMPIjvm::jv.LongClassRef, |
/* @NOTE |
JMPIjvm::jv.LongNewJ, |
** This does not work for some reason on the client java code: |
(jlong)s64[i])); |
** DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::Java_org_pegasus_jmpi_CIMClient__1execQuery: jEnv = "<<PEGASUS_STD(hex)<<(int)jEnv<<", jThs = "<<(int)jThs<<PEGASUS_STD(dec)<<", jCc = "<<jCc<<", jNs = "<<jNs<<", jCop = "<<jCop<<", jQuery = "<<PEGASUS_STD(hex)<<(int)jQuery<<", jQl = "<<(int)jQl<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
} |
** What does work is: |
return jlongA; |
** printf ("This is a test\n"); |
} |
** |
case CIMTYPE_UINT64: |
** To debug these JNI functions insert the following: |
{ |
** if (getenv ("PEGASUS_JMPI_GDB")) |
Array<Uint64> u64; |
** { |
cv->get (u64); |
** bool fLoop = true; |
int s = u64.size (); |
** int i = 0; |
jobjectArray ju64A = (jobjectArray)jEnv->NewObjectArray( |
** |
s, |
** while (fLoop) |
JMPIjvm::jv.UnsignedInt64ClassRef, |
** { |
0); |
** i = 1; |
|
** } |
|
** } |
|
** Export the variable PEGASUS_JMPI_GDB=1. |
|
** Start gdb in another process. |
|
** shell ps -efl |
|
** att <ps number> |
|
** set fLoop = 0 |
|
*/ |
|
| |
jEnv->ReleaseStringUTFChars(jQuery,str); |
for (int i = 0; i < s; i++) |
|
{ |
|
std::ostringstream oss; |
|
jstring jString = 0; |
|
jobject jBIG = 0; |
| |
str=jEnv->GetStringUTFChars(jQl,NULL); |
oss << u64[i] << ends; |
| |
String ql(str); |
jString = jEnv->NewStringUTF (oss.str ().c_str ()); |
| |
jEnv->ReleaseStringUTFChars(jQl,str); |
if (jString) |
|
{ |
|
jBIG = jEnv->NewObject( |
|
JMPIjvm::jv.UnsignedInt64ClassRef, |
|
JMPIjvm::jv.UnsignedInt64NewStr, |
|
jString); |
|
} |
| |
try { |
if (jBIG) |
checkNs(cop,jNs); |
{ |
Array<CIMObject> enm=cCc->execQuery(cop->getNameSpace(),ql,query); |
jEnv->SetObjectArrayElement( |
Array<CIMInstance> *enmInst=new Array<CIMInstance>(); |
ju64A, |
for (int i=0,m=enm.size(); i<m; i++) { |
i, |
enmInst->append(CIMInstance(enm[i])); |
jEnv->NewObject( |
|
JMPIjvm::jv.UnsignedInt64ClassRef, |
|
JMPIjvm::jv.UnsignedInt64NewBi, |
|
jBIG)); |
} | } |
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst); |
|
} | } |
Catch(jEnv); |
return ju64A; |
|
|
return 0; |
|
} | } |
|
case CIMTYPE_REAL32: |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associatorNames |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, |
|
jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole) |
|
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
Array<Real32> r32; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
cv->get (r32); |
const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); |
int s = r32.size (); |
CIMName assocClass(str); |
jobjectArray jfloatA = (jobjectArray)jEnv->NewObjectArray( |
|
s, |
jEnv->ReleaseStringUTFChars(jAssocClass,str); |
JMPIjvm::jv.FloatClassRef, |
str=jEnv->GetStringUTFChars(jResultClass,NULL); |
0); |
|
|
CIMName resultClass(str); |
|
|
|
jEnv->ReleaseStringUTFChars(jResultClass,str); |
|
str=jEnv->GetStringUTFChars(jRole,NULL); |
|
|
|
String role(str); |
|
| |
jEnv->ReleaseStringUTFChars(jRole,str); |
for (int i = 0; i < s; i++) |
str=jEnv->GetStringUTFChars(jResultRole,NULL); |
{ |
|
jEnv->SetObjectArrayElement( |
|
jfloatA, |
|
i, |
|
jEnv->NewObject( |
|
JMPIjvm::jv.FloatClassRef, |
|
JMPIjvm::jv.FloatNewF, |
|
(jfloat)r32[i])); |
|
} |
|
return jfloatA; |
|
} |
|
case CIMTYPE_REAL64: |
|
{ |
|
Array<Real64> r64; |
| |
String resultRole(str); |
cv->get (r64); |
| |
jEnv->ReleaseStringUTFChars(jResultRole,str); |
int s = r64.size (); |
|
jobjectArray jdoubleA = (jobjectArray)jEnv->NewObjectArray( |
|
s, |
|
JMPIjvm::jv.DoubleClassRef, |
|
0); |
| |
try { |
for (int i = 0; i < s; i++) |
checkNs(cop,jNs); |
{ |
Array<CIMObjectPath> enm=cCc->associatorNames( |
jEnv->SetObjectArrayElement( |
cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole); |
jdoubleA, |
return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm)); |
i, |
|
jEnv->NewObject( |
|
JMPIjvm::jv.DoubleClassRef, |
|
JMPIjvm::jv.DoubleNewD, |
|
(jdouble)r64[i])); |
} | } |
Catch(jEnv); |
return jdoubleA; |
|
|
return 0; |
|
} | } |
|
case CIMTYPE_STRING: |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associators |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, |
|
jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole, |
|
jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl) |
|
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
Array<String> str; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
cv->get(str); |
CIMPropertyList pl = getList(jEnv,jPl); |
int s = str.size (); |
const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); |
jobjectArray jstringA = (jobjectArray)jEnv->NewObjectArray( |
CIMName assocClass(str); |
s, |
|
JMPIjvm::jv.StringClassRef, |
|
0); |
| |
jEnv->ReleaseStringUTFChars(jAssocClass,str); |
for (int i = 0; i < s; i++) |
str=jEnv->GetStringUTFChars(jResultClass,NULL); |
{ |
|
jEnv->SetObjectArrayElement( |
|
jstringA, |
|
i, |
|
jEnv->NewStringUTF (str[i].getCString ())); |
|
} |
|
return jstringA; |
|
} |
|
case CIMTYPE_REFERENCE: |
|
{ |
|
Array<CIMObjectPath> ref; |
| |
CIMName resultClass(str); |
cv->get (ref); |
| |
jEnv->ReleaseStringUTFChars(jResultClass,str); |
int s = ref.size (); |
str=jEnv->GetStringUTFChars(jRole,NULL); |
jobjectArray jrefA = (jobjectArray)jEnv->NewObjectArray( |
|
s, |
|
JMPIjvm::jv.CIMObjectPathClassRef, |
|
0); |
| |
String role(str); |
for (int i = 0; i < s; i++) |
|
{ |
|
jlong jOP = DEBUG_ConvertCToJava( |
|
CIMObjectPath*, |
|
jlong, |
|
new CIMObjectPath(ref[i])); |
| |
jEnv->ReleaseStringUTFChars(jRole,str); |
jEnv->SetObjectArrayElement (jrefA, |
str=jEnv->GetStringUTFChars(jResultRole,NULL); |
i, |
|
jEnv->NewObject( |
|
JMPIjvm::jv.CIMObjectPathClassRef, |
|
JMPIjvm::jv.CIMObjectPathNewJ, |
|
jOP)); |
|
} |
|
return jrefA; |
|
} |
|
case CIMTYPE_CHAR16: |
|
{ |
|
Array<Char16> c16; |
| |
String resultRole(str); |
cv->get (c16); |
| |
jEnv->ReleaseStringUTFChars(jResultRole,str); |
int s = c16.size (); |
|
jobjectArray jc16A = (jobjectArray)jEnv->NewObjectArray( |
|
s, |
|
JMPIjvm::jv.CharacterClassRef, |
|
0); |
| |
try { |
for (int i = 0; i < s; i++) |
checkNs(cop,jNs); |
{ |
Array<CIMObject> enm=cCc->associators( |
jEnv->SetObjectArrayElement( |
cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole, |
jc16A, |
(Boolean)includeQualifiers,(Boolean)includeClassOrigin,pl); |
i, |
Array<CIMInstance> *enmInst=new Array<CIMInstance>(); |
jEnv->NewObject( |
for (int i=0,m=enm.size(); i<m; i++) { |
JMPIjvm::jv.CharacterClassRef, |
enmInst->append(CIMInstance(enm[i])); |
JMPIjvm::jv.CharacterNewC, |
} |
(jchar)c16[i])); |
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst); |
|
} | } |
Catch(jEnv); |
return jc16A; |
|
|
return 0; |
|
} | } |
|
case CIMTYPE_DATETIME: |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1referenceNames |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, |
|
jstring jAssocClass, jstring jRole) |
|
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
Array<CIMDateTime> dt; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); |
|
CIMName assocClass(str); |
|
| |
jEnv->ReleaseStringUTFChars(jAssocClass,str); |
cv->get (dt); |
str=jEnv->GetStringUTFChars(jRole,NULL); |
|
| |
String role(str); |
int s = dt.size (); |
|
jobjectArray jdtA = (jobjectArray)jEnv->NewObjectArray( |
|
s, |
|
JMPIjvm::jv.CIMDateTimeClassRef, |
|
0); |
| |
jEnv->ReleaseStringUTFChars(jRole,str); |
for (int i = 0; i < s; i++) |
|
{ |
|
jlong jDT = DEBUG_ConvertCToJava( |
|
CIMDateTime*, |
|
jlong, |
|
new CIMDateTime (dt[i])); |
| |
try { |
jEnv->SetObjectArrayElement( |
checkNs(cop,jNs); |
jdtA, |
Array<CIMObjectPath> enm=cCc->referenceNames( |
i, |
cop->getNameSpace(),*cop,assocClass,role); |
jEnv->NewObject( |
return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm)); |
JMPIjvm::jv.CIMDateTimeClassRef, |
|
JMPIjvm::jv.CIMDateTimeNewJ, |
|
jDT)); |
} | } |
Catch(jEnv); |
return jdtA; |
|
|
return 0; |
|
} | } |
|
case CIMTYPE_OBJECT: |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1references |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, |
|
jstring jAssocClass, jstring jRole, |
|
jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl) |
|
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
Array<CIMObject> co; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
CIMPropertyList pl = getList(jEnv,jPl); |
|
const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); |
|
CIMName assocClass(str); |
|
| |
jEnv->ReleaseStringUTFChars(jAssocClass,str); |
cv->get (co); |
str=jEnv->GetStringUTFChars(jRole,NULL); |
|
| |
String role(str); |
int s = co.size (); |
|
jobjectArray jcoA = (jobjectArray)jEnv->NewObjectArray( |
|
s, |
|
JMPIjvm::jv.CIMObjectClassRef, |
|
0); |
| |
jEnv->ReleaseStringUTFChars(jRole,str); |
for (int i = 0; i < s; i++) |
|
{ |
|
if (co[i].isClass ()) |
|
{ |
|
jlong jCC = DEBUG_ConvertCToJava( |
|
CIMClass*, |
|
jlong, |
|
new CIMClass (co[i])); |
| |
try { |
jEnv->SetObjectArrayElement( |
checkNs(cop,jNs); |
jcoA, |
Array<CIMObject> enm=cCc->references( |
i, |
cop->getNameSpace(),*cop,assocClass,role, |
jEnv->NewObject( |
(Boolean)includeQualifiers,(Boolean)includeClassOrigin,pl); |
JMPIjvm::jv.CIMObjectClassRef, |
Array<CIMInstance> *enmInst=new Array<CIMInstance>(); |
JMPIjvm::jv.CIMObjectNewJZ, |
for (int i=0,m=enm.size(); i<m; i++) { |
jCC, |
enmInst->append(CIMInstance(enm[i])); |
(jboolean)true)); |
} |
|
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst); |
|
} | } |
Catch(jEnv); |
else |
|
{ |
|
jlong jCI = DEBUG_ConvertCToJava( |
|
CIMInstance*, |
|
jlong, |
|
new CIMInstance (co[i])); |
| |
return 0; |
jEnv->SetObjectArrayElement( |
|
jcoA, |
|
i, |
|
jEnv->NewObject( |
|
JMPIjvm::jv.CIMObjectClassRef, |
|
JMPIjvm::jv.CIMObjectNewJZ, |
|
jCI, |
|
(jboolean)false)); |
} | } |
|
|
static int normalizeNs(String &ns, String &nsBase, String &lastNsComp) { |
|
Uint32 n=ns.size(); |
|
if (ns[n-1]=='/') { |
|
if (n>=2) ns=ns.subString(0,n-2); |
|
} | } |
|
return jcoA; |
lastNsComp=ns; |
} |
nsBase="root"; |
default: |
|
throwCIMException (jEnv,"+++ unsupported type: "); |
n=ns.reverseFind('/'); |
|
if (n!=PEG_NOT_FOUND) { |
|
lastNsComp=ns.subString(n+1); |
|
nsBase=ns.subString(0,n); |
|
} | } |
return 0; |
|
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createNameSpace |
return NULL; |
(JNIEnv *jEnv, jobject jThs, jint jCc, jstring jNs) |
} |
{ |
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
|
const char *str = jEnv->GetStringUTFChars(jNs,NULL); |
|
String ns(str); |
|
| |
jEnv->ReleaseStringUTFChars(jNs,str); |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType |
|
(JNIEnv *jEnv, jobject jThs, jlong jP) |
|
{ |
|
CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jP); |
|
bool fSuccess = false; |
|
jint jiJType = 0; |
| |
String lastNsComp; |
jiJType = _dataType::convertCTypeToJavaType (cv->getType (), &fSuccess); |
String nsBase; |
|
| |
normalizeNs(ns,nsBase,lastNsComp); |
return jiJType; |
|
} |
| |
CIMInstance newInstance(CIMName("__Namespace")); |
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMValue__1isArray |
newInstance.addProperty(CIMProperty(CIMName ("name"),lastNsComp)); |
(JNIEnv *jEnv, jobject jThs, jlong jP) |
|
{ |
|
CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jP); |
| |
try { |
return (jboolean)cv->isArray (); |
cCc->createInstance(CIMNamespaceName(nsBase),newInstance); |
|
} | } |
Catch(jEnv); |
|
|
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString |
|
(JNIEnv *jEnv, jobject jThs, jlong jV) |
|
{ |
|
CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV); |
|
|
|
return (jstring)jEnv->NewStringUTF (cv->toString ().getCString ()); |
} | } |
| |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateNameSpaces |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMValue__1finalize |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jboolean deep, jobject jVec) |
(JNIEnv *jEnv, jobject jThs, jlong jV) |
{ | { |
JMPIjvm::cacheIDs(jEnv); |
CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV); |
| |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
delete cv; |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
|
String ns = cop->getNameSpace().getString(); |
|
| |
try { |
DEBUG_ConvertCleanup (jlong, jV); |
Array<CIMObjectPath> enm=cCc->enumerateInstanceNames( |
|
cop->getNameSpace(),CIMName("__Namespace")); |
|
for (int i=0,s=enm.size(); i<s; i++) { |
|
CIMObjectPath &cop=enm[i]; |
|
const Array<CIMKeyBinding>& kb=cop.getKeyBindings(); |
|
const String &n=kb[0].getValue(); |
|
if (!deep && n.find('/')!=PEG_NOT_FOUND) |
|
continue; |
|
String x=ns+"/"+n; |
|
jstring str=jEnv->NewStringUTF(x.getCString()); |
|
jEnv->CallVoidMethod(jVec,JMPIjvm::jv.VectorAddElement,str); |
|
} | } |
} |
|
Catch(jEnv); |
|
| |
return jVec; |
|
|
// ------------------------------------- |
|
// --- |
|
// - ClassEnumeration |
|
// --- |
|
// ------------------------------------- |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1getClass |
|
(JNIEnv *jEnv, jobject jThs, jlong jEnum, jint pos) |
|
{ |
|
Array<CIMClass> *enm = DEBUG_ConvertJavaToC(jlong, Array<CIMClass>*, jEnum); |
|
|
|
return DEBUG_ConvertCToJava (CIMClass*, jlong, new CIMClass ((*enm)[pos])); |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteNameSpace |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1size |
(JNIEnv *jEnv, jobject jThs, jint jCc, jstring jNs) |
(JNIEnv *jEnv, jobject jThs, jlong jEnum) |
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
Array<CIMClass> *enm = DEBUG_ConvertJavaToC(jlong, Array<CIMClass>*, jEnum); |
const char *str = jEnv->GetStringUTFChars(jNs,NULL); |
|
String ns(str); |
|
| |
jEnv->ReleaseStringUTFChars(jNs,str); |
return enm->size (); |
|
} |
| |
String lastNsComp; |
|
String nsBase; |
|
| |
normalizeNs(ns,nsBase,lastNsComp); |
// ------------------------------------- |
|
// --- |
|
// - InstEnumeration |
|
// --- |
|
// ------------------------------------- |
| |
CIMObjectPath cop(String::EMPTY,CIMNamespaceName(nsBase),CIMName("__Namespace")); |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_InstEnumeration__1getInstance |
Array<CIMKeyBinding> kb; |
(JNIEnv *jEnv, jobject jThs, jlong jEnum, jint pos) |
kb.append(CIMKeyBinding(("Name"),CIMValue(lastNsComp))); |
{ |
cop.setKeyBindings(kb); |
Array<CIMInstance> *enm = DEBUG_ConvertJavaToC( |
|
jlong, |
|
Array<CIMInstance>*, |
|
jEnum); |
| |
try { |
return DEBUG_ConvertCToJava( |
cCc->deleteInstance(CIMNamespaceName(nsBase),cop); |
CIMInstance*, |
|
jlong, |
|
new CIMInstance((*enm)[pos])); |
} | } |
Catch(jEnv); |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1size |
|
(JNIEnv *jEnv, jobject jThs, jlong jEnum) |
|
{ |
|
Array<CIMInstance> *enm = DEBUG_ConvertJavaToC( |
|
jlong, |
|
Array<CIMInstance>*, |
|
jEnum); |
|
|
|
return enm->size (); |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1finalize |
// ------------------------------------- |
(JNIEnv *jEnv, jobject jThs, jint jCc) |
// --- |
|
// - JMPIQueryExp |
|
// --- |
|
// ------------------------------------- |
|
|
|
/* |
|
* Class: org_pegasus_jmpi_JMPIQueryExp |
|
* Method: _applyInstance |
|
* Signature: (II)Z |
|
*/ |
|
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_JMPIQueryExp__1applyInstance |
|
(JNIEnv *jEnv, jobject jThs, jlong jWQLStmt, jlong jciInstance) |
{ | { |
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC( |
|
jlong, |
|
WQLSelectStatement*, |
|
jWQLStmt); |
|
CIMInstance *ci = DEBUG_ConvertJavaToC( |
|
jlong, |
|
CIMInstance*, |
|
jciInstance); |
| |
delete cCc; |
if ( !wql_stmt |
|
|| !ci |
|
) |
|
{ |
|
return 0; |
|
} |
|
|
|
try |
|
{ |
|
return wql_stmt->evaluate (*ci); |
|
} |
|
catch (const Exception &e) |
|
{ |
|
cerr << "Java_org_pegasus_jmpi_JMPIQueryExp__1applyInstance: Caught: " |
|
<< e.getMessage () << endl; |
| |
DEBUG_ConvertCleanup (jint, jCc); |
return false; |
} | } |
|
} |
|
|
| |
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
// - CIMObject |
// - JMPISelectList |
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObject__1newClass |
/* |
(JNIEnv *jEnv, jobject jThs, jint jCc) |
* Class: org_pegasus_jmpi_JMPISelectList |
|
* Method: _applyInstance |
|
* Signature: (II)I |
|
*/ |
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyInstance |
|
(JNIEnv *jEnv, jobject jThs, jlong jWQLStmt, jlong jciInstance) |
|
{ |
|
WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC( |
|
jlong, |
|
WQLSelectStatement*, |
|
jWQLStmt); |
|
CIMInstance *ci = DEBUG_ConvertJavaToC( |
|
jlong, |
|
CIMInstance*, |
|
jciInstance); |
|
CIMInstance *ciRet = 0; |
|
|
|
if ( !wql_stmt |
|
|| !ci |
|
) |
{ | { |
CIMClass *cCc = DEBUG_ConvertJavaToC (jint, CIMClass*, jCc); |
return 0; |
|
} |
| |
try { |
ciRet = new CIMInstance (ci->clone ()); |
CIMObject *cCo = new CIMObject (*cCc); |
|
| |
return DEBUG_ConvertCToJava (CIMObject*, jint, cCo); |
if (ciRet) |
|
{ |
|
try |
|
{ |
|
wql_stmt->applyProjection (*ciRet, false); |
} | } |
Catch(jEnv); |
catch (const Exception &e) |
|
{ |
|
cerr << "Java_org_pegasus_jmpi_JMPISelectList__1applyInstance:" |
|
" Caught: " |
|
<< e.getMessage () << endl; |
| |
return 0; | return 0; |
} | } |
|
} |
|
|
|
return DEBUG_ConvertCToJava (CIMInstance *, jlong, ciRet); |
|
} |
|
|
|
/* |
|
* Class: org_pegasus_jmpi_JMPISelectList |
|
* Method: _applyClass |
|
* Signature: (II)I |
|
*/ |
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyClass |
|
(JNIEnv *jEnv, jobject jThs, jlong jWQLStmt, jlong jciClass) |
|
{ |
|
WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC( |
|
jlong, |
|
WQLSelectStatement*, |
|
jWQLStmt); |
|
CIMClass *cc = DEBUG_ConvertJavaToC( |
|
jlong, |
|
CIMClass*, |
|
jciClass); |
|
CIMClass *ccRet = NULL; |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObject__1newInstance |
if (!wql_stmt) |
(JNIEnv *jEnv, jobject jThs, jint jCi) |
|
{ | { |
CIMInstance *cCi = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi); |
return 0; |
|
} |
| |
try { |
if (cc) |
CIMObject *cCo = new CIMObject (*cCi); |
{ |
|
CIMObject co (cc->clone ()); |
| |
return DEBUG_ConvertCToJava (CIMObject*, jint, cCo); |
try |
|
{ |
|
wql_stmt->applyProjection (co, false); |
} | } |
Catch(jEnv); |
catch (const Exception &e) |
|
{ |
|
cerr << "Java_org_pegasus_jmpi_JMPISelectList__1applyClass: Caught: " |
|
<< e.getMessage () << endl; |
| |
return 0; | return 0; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObject__1finalize |
ccRet = new CIMClass (co); |
(JNIEnv *jEnv, jobject jThs, jint jInst) |
|
{ |
|
CIMObject *co = DEBUG_ConvertJavaToC (jint, CIMObject*, jInst); |
|
| |
delete co; |
return DEBUG_ConvertCToJava (CIMClass *, jlong, ccRet); |
|
} |
| |
DEBUG_ConvertCleanup (jint, jInst); |
return 0; |
} | } |
| |
|
|
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
// - OperationContext | // - OperationContext |
|
|
* Signature: (ILjava/lang/String;Ljava/lang/String;)Ljava/lang/Object; | * Signature: (ILjava/lang/String;Ljava/lang/String;)Ljava/lang/Object; |
*/ | */ |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_OperationContext__1get | JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_OperationContext__1get |
(JNIEnv *jEnv, jobject jThs, jint jInst, jstring jContainer, jstring jKey) |
(JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jContainer, jstring jKey) |
{ | { |
OperationContext *poc = DEBUG_ConvertJavaToC (jint, OperationContext*, jInst); |
OperationContext *poc = DEBUG_ConvertJavaToC( |
|
jlong, |
|
OperationContext*, |
|
jInst); |
jobject jRet = 0; | jobject jRet = 0; |
| |
if (!poc) | if (!poc) |
|
|
String container (pszContainer); | String container (pszContainer); |
String key (pszKey); | String key (pszKey); |
| |
///printf ("container: %s\n", pszContainer); |
|
///printf ("key: %s\n", pszKey); |
|
|
|
try { | try { |
if (container == "IdentityContainer") | if (container == "IdentityContainer") |
{ | { |
IdentityContainer ic = poc->get (IdentityContainer::NAME); | IdentityContainer ic = poc->get (IdentityContainer::NAME); |
|
|
/////////printf ("ic\n"); |
|
|
|
if (key == "userName") | if (key == "userName") |
{ | { |
String userName = ic.getUserName (); | String userName = ic.getUserName (); |
|
|
////////////printf ("userName: %s\n", (const char*)userName.getCString ()); |
|
|
|
jRet = jEnv->NewStringUTF ((const char*)userName.getCString ()); | jRet = jEnv->NewStringUTF ((const char*)userName.getCString ()); |
} | } |
} | } |
else if (container == "SubscriptionInstanceContainer") | else if (container == "SubscriptionInstanceContainer") |
{ | { |
SubscriptionInstanceContainer sic = poc->get (SubscriptionInstanceContainer::NAME); |
SubscriptionInstanceContainer sic = |
|
poc->get(SubscriptionInstanceContainer::NAME); |
| |
if (key == "subscriptionInstance") | if (key == "subscriptionInstance") |
{ | { |
CIMInstance ci = sic.getInstance (); | CIMInstance ci = sic.getInstance (); |
jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance (ci)); |
jlong jciRef = DEBUG_ConvertCToJava( |
|
CIMInstance*, |
|
jlong, |
|
new CIMInstance (ci)); |
| |
jRet = jEnv->NewObject (JMPIjvm::jv.CIMInstanceClassRef, | jRet = jEnv->NewObject (JMPIjvm::jv.CIMInstanceClassRef, |
JMPIjvm::jv.CIMInstanceNewI, |
JMPIjvm::jv.CIMInstanceNewJ, |
jciRef); | jciRef); |
} | } |
} | } |
else if (container == "SubscriptionInstanceNamesContainer") | else if (container == "SubscriptionInstanceNamesContainer") |
{ | { |
SubscriptionInstanceNamesContainer sinc = poc->get (SubscriptionInstanceNamesContainer::NAME); |
SubscriptionInstanceNamesContainer sinc= |
|
poc->get (SubscriptionInstanceNamesContainer::NAME); |
| |
if (key == "subscriptionInstanceNames") | if (key == "subscriptionInstanceNames") |
{ | { |
|
|
jobjectArray jcopa = 0; | jobjectArray jcopa = 0; |
int jcopaLength = copa.size (); | int jcopaLength = copa.size (); |
| |
jcopa = jEnv->NewObjectArray (jcopaLength, |
jcopa = (jobjectArray)jEnv->NewObjectArray( |
|
jcopaLength, |
JMPIjvm::jv.CIMObjectPathClassRef, | JMPIjvm::jv.CIMObjectPathClassRef, |
0); | 0); |
| |
for (int i = 0; i < jcopaLength; i++) | for (int i = 0; i < jcopaLength; i++) |
{ | { |
jEnv->SetObjectArrayElement (jcopa, |
jEnv->SetObjectArrayElement( |
|
jcopa, |
i, | i, |
jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef, |
jEnv->NewObject( |
JMPIjvm::jv.CIMObjectPathNewI, |
JMPIjvm::jv.CIMObjectPathClassRef, |
|
JMPIjvm::jv.CIMObjectPathNewJ, |
new CIMObjectPath (copa[i]))); | new CIMObjectPath (copa[i]))); |
} | } |
| |
|
|
} | } |
else if (container == "SubscriptionFilterConditionContainer") | else if (container == "SubscriptionFilterConditionContainer") |
{ | { |
SubscriptionFilterConditionContainer sfcc = poc->get (SubscriptionFilterConditionContainer::NAME); |
SubscriptionFilterConditionContainer sfcc = |
|
poc->get (SubscriptionFilterConditionContainer::NAME); |
/////////printf ("sfcc\n"); |
|
| |
if (key == "filterCondition") | if (key == "filterCondition") |
{ | { |
String filterCondition = sfcc.getFilterCondition (); | String filterCondition = sfcc.getFilterCondition (); |
| |
////////////printf ("filterCondition: %s\n", (const char*)filterCondition.getCString ()); |
|
|
|
jRet = jEnv->NewStringUTF ((const char*)filterCondition.getCString ()); | jRet = jEnv->NewStringUTF ((const char*)filterCondition.getCString ()); |
} | } |
else if (key == "queryLanguage") | else if (key == "queryLanguage") |
|
|
} | } |
else if (container == "SubscriptionFilterQueryContainer") | else if (container == "SubscriptionFilterQueryContainer") |
{ | { |
SubscriptionFilterQueryContainer sfqc = poc->get (SubscriptionFilterQueryContainer::NAME); |
SubscriptionFilterQueryContainer sfqc = |
|
poc->get(SubscriptionFilterQueryContainer::NAME); |
| |
if (key == "filterQuery") | if (key == "filterQuery") |
{ | { |
|
|
return jRet; | return jRet; |
} | } |
| |
|
|
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
// - SelectExp |
// - PathEnumeration |
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
/* |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_PathEnumeration__1getObjectPath |
* Class: org_pegasus_jmpi_SelectExp |
(JNIEnv *jEnv, jobject jThs, jlong jEnum, jint pos) |
* Method: _finalize |
|
* Signature: (I)V |
|
*/ |
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_SelectExp__1finalize |
|
(JNIEnv *jEnv, jobject jThs, jint jEselx) |
|
{ | { |
CMPI_SelectExp *eSelx = DEBUG_ConvertJavaToC (jint, CMPI_SelectExp*, jEselx); |
Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC( |
|
jlong, |
delete eSelx; |
Array<CIMObjectPath>*, |
|
jEnum); |
| |
DEBUG_ConvertCleanup (jint, jEselx); |
return DEBUG_ConvertCToJava( |
|
CIMObjectPath*, |
|
jlong, |
|
new CIMObjectPath((*enm)[pos])); |
} | } |
| |
/* |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1size |
* Class: org_pegasus_jmpi_SelectExp |
(JNIEnv *jEnv, jobject jThs, jlong jEnum) |
* Method: _newSelectExp |
|
* Signature: (Ljava/lang/String;)I |
|
*/ |
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_SelectExp__1newSelectExp |
|
(JNIEnv *jEnv, jobject jThs, jstring jQuery) |
|
{ | { |
const char *pszQuery = jEnv->GetStringUTFChars (jQuery, NULL); |
Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC( |
CMPI_SelectExp *eSelx = NULL; |
jlong, |
WQLSelectStatement *stmt = NULL; |
Array<CIMObjectPath>*, |
String queryLanguage (CALL_SIGN_WQL); |
jEnum); |
String query (pszQuery); |
|
| |
stmt = new WQLSelectStatement (queryLanguage, query); |
return enm->size (); |
eSelx = new CMPI_SelectExp (stmt); |
} |
| |
jEnv->ReleaseStringUTFChars (jQuery, pszQuery); |
|
| |
return DEBUG_ConvertCToJava (CMPI_SelectExp *, jint, eSelx); |
// ------------------------------------- |
|
// --- |
|
// - QualEnumeration |
|
// --- |
|
// ------------------------------------- |
|
|
|
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_QualEnumeration__1getQualifierType |
|
(JNIEnv *jEnv, jobject jThs, jlong jEnum, jint pos) |
|
{ |
|
Array<CIMQualifierDecl> *enm = DEBUG_ConvertJavaToC( |
|
jlong, |
|
Array<CIMQualifierDecl>*, |
|
jEnum); |
|
|
|
return DEBUG_ConvertCToJava( |
|
CIMQualifierDecl*, |
|
jlong, |
|
new CIMQualifierDecl((*enm)[pos])); |
} | } |
| |
/* |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1size |
* Class: org_pegasus_jmpi_SelectExp |
(JNIEnv *jEnv, jobject jThs, jlong jEnum) |
* Method: _getSelectString |
|
* Signature: (I)Ljava/lang/String; |
|
*/ |
|
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_SelectExp__1getSelectString |
|
(JNIEnv *jEnv, jobject jThs, jint jEselx) |
|
{ | { |
CMPI_SelectExp *eSelx = DEBUG_ConvertJavaToC (jint, CMPI_SelectExp*, jEselx); |
Array<CIMQualifierDecl> *enm = DEBUG_ConvertJavaToC( |
|
jlong, |
|
Array<CIMQualifierDecl>*, |
|
jEnum); |
| |
return (jstring)jEnv->NewStringUTF (eSelx->cond.getCString ()); |
return enm->size (); |
} | } |
| |
|
|
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
// - JMPISelectList |
// - SelectExp |
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
/* | /* |
* Class: org_pegasus_jmpi_JMPISelectList |
* Class: org_pegasus_jmpi_SelectExp |
* Method: _applyInstance |
* Method: _finalize |
* Signature: (II)I |
* Signature: (I)V |
*/ | */ |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyInstance |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_SelectExp__1finalize |
(JNIEnv *jEnv, jobject jThs, jint jEselx, jint jciInstance) |
(JNIEnv *jEnv, jobject jThs, jlong jWQLStmt) |
{ |
|
CMPI_SelectExp *eSelx = DEBUG_ConvertJavaToC (jint, CMPI_SelectExp*, jEselx); |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciInstance); |
|
CIMInstance *ciRet = 0; |
|
|
|
if ( !eSelx |
|
|| !eSelx->wql_stmt |
|
) |
|
{ | { |
return 0; |
WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC ( |
} |
jlong, |
|
WQLSelectStatement*, |
ciRet = new CIMInstance (ci->clone ()); |
jWQLStmt); |
| |
if (ciRet) |
delete wql_stmt; |
{ |
|
eSelx->wql_stmt->applyProjection (*ciRet, false); |
|
} |
|
| |
return DEBUG_ConvertCToJava (CIMInstance *, jint, ciRet); |
DEBUG_ConvertCleanup (jlong, jWQLStmt); |
} | } |
| |
/* | /* |
* Class: org_pegasus_jmpi_JMPISelectList |
* Class: org_pegasus_jmpi_SelectExp |
* Method: _applyClass |
* Method: _newSelectExp |
* Signature: (II)I |
* Signature: (Ljava/lang/String;)I |
*/ | */ |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyClass |
JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_SelectExp__1newSelectExp |
(JNIEnv *jEnv, jobject jThs, jint jEselx, jint jciClass) |
(JNIEnv *jEnv, jobject jThs, jstring jQuery) |
{ | { |
CMPI_SelectExp *eSelx = DEBUG_ConvertJavaToC (jint, CMPI_SelectExp*, jEselx); |
const char *pszQuery = jEnv->GetStringUTFChars (jQuery, NULL); |
CIMClass *cc = DEBUG_ConvertJavaToC (jint, CIMClass*, jciClass); |
WQLSelectStatement *wql_stmt = NULL; |
CIMClass *ccRet = NULL; |
String queryLanguage (CALL_SIGN_WQL); |
|
String query (pszQuery); |
| |
if ( !eSelx |
wql_stmt = new WQLSelectStatement (queryLanguage, query); |
|| !eSelx->wql_stmt |
|
) |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4, |
|
"Java_org_pegasus_jmpi_SelectExp__1newSelectExp: wql_stmt = %p", |
|
wql_stmt)); |
|
|
|
try |
{ | { |
return 0; |
WQLParser::parse (query, *wql_stmt); |
} | } |
|
catch (const Exception &e) |
if (cc) |
|
{ | { |
CIMObject co (cc->clone ()); |
PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4, |
|
"Java_org_pegasus_jmpi_SelectExp__1newSelectExp: Caught: %s", |
eSelx->wql_stmt->applyProjection (co, false); |
(const char*)e.getMessage().getCString())); |
|
|
ccRet = new CIMClass (co); |
|
|
|
return DEBUG_ConvertCToJava (CIMClass *, jint, ccRet); |
|
} | } |
| |
return 0; |
jEnv->ReleaseStringUTFChars (jQuery, pszQuery); |
} |
|
| |
// ------------------------------------- |
return DEBUG_ConvertCToJava (WQLSelectStatement *, jlong, wql_stmt); |
// --- |
} |
// - JMPIQueryExp |
|
// --- |
|
// ------------------------------------- |
|
| |
/* | /* |
* Class: org_pegasus_jmpi_JMPIQueryExp |
* Class: org_pegasus_jmpi_SelectExp |
* Method: _applyInstance |
* Method: _getSelectString |
* Signature: (II)Z |
* Signature: (I)Ljava/lang/String; |
*/ | */ |
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_JMPIQueryExp__1applyInstance |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_SelectExp__1getSelectString |
(JNIEnv *jEnv, jobject jThs, jint jEselx, jint jciInstance) |
(JNIEnv *jEnv, jobject jThs, jlong jWQLStmt) |
{ | { |
CMPI_SelectExp *eSelx = DEBUG_ConvertJavaToC (jint, CMPI_SelectExp*, jEselx); |
WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC( |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciInstance); |
jlong, |
|
WQLSelectStatement*, |
|
jWQLStmt); |
|
String cond; |
| |
if ( !eSelx |
if (wql_stmt) |
|| !eSelx->wql_stmt |
|
) |
|
{ | { |
return 0; |
try |
|
{ |
|
cond = wql_stmt->getQuery (); |
} | } |
|
catch (const Exception &e) |
|
{ |
|
cerr << "Java_org_pegasus_jmpi_SelectExp__1getSelectString: Caught: " |
|
<< e.getMessage () << endl; |
| |
if (eSelx->wql_stmt) |
cond = ""; |
|
} |
|
} |
|
else |
{ | { |
return eSelx->wql_stmt->evaluate (*ci); |
cond = ""; |
} | } |
| |
return false; |
return (jstring)jEnv->NewStringUTF (cond.getCString ()); |
} | } |
| |
} // extern "C" | } // extern "C" |