version 1.22, 2005/05/23 20:43:47
|
version 1.47, 2006/07/27 08:33:24
|
|
|
//%2005//////////////////////////////////////////////////////////////////////// |
//%2006//////////////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development | // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. | // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. |
|
|
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. | // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; | // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
// EMC Corporation; VERITAS Software Corporation; The Open Group. | // 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 copy |
// of this software and associated documentation files (the "Software"), to | // of this software and associated documentation files (the "Software"), to |
|
|
// Magda Vacarelu | // Magda Vacarelu |
// David Dillard, VERITAS Software Corp. | // David Dillard, VERITAS Software Corp. |
// (david.dillard@veritas.com) | // (david.dillard@veritas.com) |
// Mark Hamzy |
// Mark Hamzy, hamzy@us.ibm.com |
// | // |
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
|
|
|
|
#include "JMPIImpl.h" | #include "JMPIImpl.h" |
| |
#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC) | #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC) |
|
|
#include <Pegasus/Common/CIMInstance.h> | #include <Pegasus/Common/CIMInstance.h> |
#include <Pegasus/Common/CIMObjectPath.h> | #include <Pegasus/Common/CIMObjectPath.h> |
#include <Pegasus/Common/CIMProperty.h> | #include <Pegasus/Common/CIMProperty.h> |
#include <Pegasus/Common/CIMType.h> |
|
#include <Pegasus/Common/OperationContext.h> | #include <Pegasus/Common/OperationContext.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/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 |
|
|
JvmVector JMPIjvm::jv; | JvmVector JMPIjvm::jv; |
int JMPIjvm::trace=0; | int JMPIjvm::trace=0; |
| |
|
#ifdef PEGASUS_DEBUG |
#define DDD(x) if (JMPIjvm::trace) x; | #define DDD(x) if (JMPIjvm::trace) x; |
|
#else |
|
#define DDD(x) |
|
#endif |
| |
#include "Convert.h" | #include "Convert.h" |
| |
JMPIjvm::ClassTable JMPIjvm::_classTable; | JMPIjvm::ClassTable JMPIjvm::_classTable; |
JMPIjvm::ObjectTable JMPIjvm::_objectTable; | JMPIjvm::ObjectTable JMPIjvm::_objectTable; |
| |
typedef struct { |
|
int clsIndex; |
|
const char * methodName; |
|
const char * signature; |
|
} METHOD_STRUCT; |
|
|
|
const char* classNames[]={ | const char* classNames[]={ |
"java/util/Vector" , // 0 |
/*00*/ "java/util/Vector" , |
"java/lang/Boolean", // 1 |
/*01*/ "java/lang/Boolean", |
"java/lang/Byte", // 2 |
/*02*/ "java/lang/Byte", |
"java/lang/Short", // 3 |
/*03*/ "java/lang/Short", |
"java/lang/Integer", // 4 |
/*04*/ "java/lang/Integer", |
"java/lang/Long", // 5 |
/*05*/ "java/lang/Long", |
"java/lang/Float", // 6 |
/*06*/ "java/lang/Float", |
"java/lang/Double", // 7 |
/*07*/ "java/lang/Double", |
"org/pegasus/jmpi/UnsignedInt8", // 8 |
/*08*/ "org/pegasus/jmpi/UnsignedInt8", |
"org/pegasus/jmpi/UnsignedInt16", // 9 |
/*09*/ "org/pegasus/jmpi/UnsignedInt16", |
"org/pegasus/jmpi/UnsignedInt32", // 10 |
/*10*/ "org/pegasus/jmpi/UnsignedInt32", |
"org/pegasus/jmpi/UnsignedInt64", // 11 |
/*11*/ "org/pegasus/jmpi/UnsignedInt64", |
"org/pegasus/jmpi/CIMObjectPath", // 12 |
/*12*/ "org/pegasus/jmpi/CIMObjectPath", |
"org/pegasus/jmpi/CIMException", // 13 |
/*13*/ "org/pegasus/jmpi/CIMException", |
"java/math/BigInteger", // 14 |
/*14*/ "java/math/BigInteger", |
"org/pegasus/jmpi/CIMProperty", // 15 |
/*15*/ "org/pegasus/jmpi/CIMProperty", |
|
/*16*/ "org/pegasus/jmpi/CIMOMHandle", |
"org/pegasus/jmpi/CIMOMHandle", // 16 |
/*17*/ "org/pegasus/jmpi/CIMClass", |
"org/pegasus/jmpi/CIMClass", // 17 |
/*18*/ "org/pegasus/jmpi/CIMInstance", |
"org/pegasus/jmpi/CIMInstance", // 18 |
/*19*/ "org/pegasus/jmpi/CIMValue", |
"org/pegasus/jmpi/CIMValue", // 19 |
/*20*/ "java/lang/Object", |
"java/lang/Object", // 20 |
/*21*/ "java/lang/Throwable", |
"java/lang/Throwable", // 21 |
/*22*/ "java/lang/String", |
"java/lang/String", // 22 |
/*23*/ "org/pegasus/jmpi/JarClassLoader", |
"org/pegasus/jmpi/JarClassLoader", // 23 |
/*24*/ "org/pegasus/jmpi/CIMDateTime", |
"org/pegasus/jmpi/CIMDateTime", // 24 |
/*25*/ "org/pegasus/jmpi/SelectExp", |
"org/pegasus/jmpi/SelectExp", // 25 |
/*26*/ "org/pegasus/jmpi/CIMQualifier", |
"org/pegasus/jmpi/CIMQualifier", // 26 |
/*27*/ "org/pegasus/jmpi/CIMQualifierType", |
"org/pegasus/jmpi/CIMQualifierType",// 27 |
/*28*/ "org/pegasus/jmpi/CIMFlavor", |
"org/pegasus/jmpi/CIMFlavor", // 28 |
/*29*/ "org/pegasus/jmpi/CIMArgument", |
"org/pegasus/jmpi/CIMArgument", // 29 |
/*30*/ "org/pegasus/jmpi/CIMInstanceException", |
"org/pegasus/jmpi/CIMInstanceException", // 30 |
/*31*/ "org/pegasus/jmpi/CIMObject", |
|
/*32*/ "java/lang/Character", |
|
/*33*/ "org/pegasus/jmpi/OperationContext", |
|
/*34*/ "java/lang/Class", |
}; | }; |
| |
|
|
const METHOD_STRUCT instanceMethodNames[]={ | const METHOD_STRUCT instanceMethodNames[]={ |
/*00*/ { 0, "<init>", "()V" }, |
/*00 VectorNew */ { /*Vector */ 0, "<init>", "()V" }, |
/*01*/ { 1, "<init>", "(Z)V" }, |
/*01 BooleanNewZ */ { /*Boolean */ 1, "<init>", "(Z)V" }, |
/*02*/ { 2, "<init>", "(B)V" }, |
/*02 ByteNewB */ { /*Byte */ 2, "<init>", "(B)V" }, |
/*03*/ { 3, "<init>", "(S)V" }, |
/*03 ShortNewS */ { /*Short */ 3, "<init>", "(S)V" }, |
/*04*/ { 4, "<init>", "(I)V" }, |
/*04 IntegerNewI */ { /*Integer */ 4, "<init>", "(I)V" }, |
/*05*/ { 5, "<init>", "(J)V" }, // ??? |
/*05 LongNewJ */ { /*Long */ 5, "<init>", "(J)V" }, |
/*06*/ { 6, "<init>", "(F)V" }, |
/*06 FloatNewF */ { /*Float */ 6, "<init>", "(F)V" }, |
/*07*/ { 7, "<init>", "(D)V" }, |
/*07 DoubleNewD */ { /*Double */ 7, "<init>", "(D)V" }, |
/*08*/ { 8, "<init>", "(S)V" }, |
/*08 UnsignedInt8NewS */ { /*UnsignedInt8 */ 8, "<init>", "(S)V" }, |
/*09*/ { 9, "<init>", "(I)V" }, |
/*09 UnsignedInt16NewI */ { /*UnsignedInt16 */ 9, "<init>", "(I)V" }, |
/*10*/ { 10,"<init>", "(J)V" }, |
/*10 UnsignedInt32NewJ */ { /*UnsignedInt32 */10, "<init>", "(J)V" }, |
/*11*/ { 11,"<init>", "(Ljava/math/BigInteger;)V" }, |
/*11 UnsignedInt64NewBi */ { /*UnsignedInt64 */11, "<init>", "(Ljava/math/BigInteger;)V" }, |
/*12*/ { 12,"<init>", "(I)V" }, |
/*12 CIMObjectPathNewI */ { /*CIMObjectPath */12, "<init>", "(I)V" }, |
/*13*/ { 13,"<init>", "(Ljava/lang/String;)V" }, |
/*13 CIMExceptionNewSt */ { /*CIMException */13, "<init>", "(Ljava/lang/String;)V" }, |
/*14*/ { 15,"<init>", "(I)V" }, |
/*14 CIMPropertyNewI */ { /*CIMProperty */15, "<init>", "(I)V" }, |
/*15*/ { 0, "addElement", "(Ljava/lang/Object;)V" }, |
/*15 VectorAddElement */ { /*Vector */ 0, "addElement", "(Ljava/lang/Object;)V" }, |
|
/*16 VectorElementAt */ { /*Vector */ 0, "elementAt", "(I)Ljava/lang/Object;" }, |
/*16*/ { 0, "elementAt", "(I)Ljava/lang/Object;" }, |
/*17 CIMOMHandleNewISt */ { /*CIMOMHandle */16, "<init>", "(ILjava/lang/String;)V" }, |
/*17*/ { 16,"<init>", "(ILjava/lang/String;)V" }, |
/*18 CIMExceptionNewI */ { /*CIMException */13, "<init>", "(I)V" }, |
/*18*/ { 13,"<init>", "(I)V" }, |
/*19 CIMClassNewI */ { /*CIMClass */17, "<init>", "(I)V" }, |
/*19*/ { 17,"<init>", "(I)V" }, |
/*20 CIMInstanceNewI */ { /*CIMInstance */18, "<init>", "(I)V" }, |
/*20*/ { 18,"<init>", "(I)V" }, |
/*21 CIMObjectPathCInst */ { /*CIMObjectPath */12, "cInst", "()I" }, |
/*21*/ { 12,"<init>", "(I)V" }, |
/*22 CIMInstanceCInst */ { /*CIMInstance */18, "cInst", "()I" }, |
/*22*/ { 12,"cInst", "()I" }, |
/*23 CIMClassCInst */ { /*CIMClass */17, "cInst", "()I" }, |
/*23*/ { 18,"cInst", "()I" }, |
/*24 ObjectToString */ { /*Object */20, "toString", "()Ljava/lang/String;" }, |
/*24*/ { 17,"cInst", "()I" }, |
/*25 ThrowableGetMessage */ { /*Throwable */21, "getMessage", "()Ljava/lang/String;" }, |
/*25*/ { 20,"toString", "()Ljava/lang/String;" }, |
/*26 CIMExceptionGetID */ { /*CIMException */13, "getID", "()Ljava/lang/String;" }, |
/*26*/ { 21,"getMessage", "()Ljava/lang/String;" }, |
/*27 VectorSize */ { /*Vector */ 0, "size", "()I" }, |
/*27*/ { 13,"getID", "()Ljava/lang/String;" }, |
/*28 CIMPropertyCInst */ { /*CIMProperty */15, "cInst", "()I" }, |
/*28*/ { 0, "size", "()I" }, |
/*29 CIMOMHandleGetClass */ { /*CIMOMHandle */16, "getClass", "(Lorg/pegasus/jmpi/CIMObjectPath;Z)Lorg/pegasus/jmpi/CIMClass;" }, |
/*29*/ { 15,"cInst", "()I" }, |
/*30 VectorRemoveElementAt */ { /*Vector */ 0, "removeElementAt", "(I)V" }, |
/*30*/ { 16,"getClass", "(Lorg/pegasus/jmpi/CIMObjectPath;Z)Lorg/pegasus/jmpi/CIMClass;" }, |
/*31 CIMValueCInst */ { /*CIMValue */19, "cInst", "()I" }, |
/*31*/ { 0, "removeElementAt", "(I)V" }, |
/*32 CIMExceptionNewISt */ { /*CIMException */13, "<init>", "(ILjava/lang/String;)V" }, |
/*32*/ { 19,"cInst", "()I" }, |
/*33 CIMExceptionGetCode */ { /*CIMException */13, "getCode", "()I" }, |
/*33*/ { 13,"<init>", "(ILjava/lang/String;)V" }, |
/*34 CIMDateTimeNewI */ { /*CIMDateTime */24, "<init>", "(I)V" }, |
/*34*/ { 13,"getCode", "()I" }, |
/*35 SelectExpNewI */ { /*SelectExp */25, "<init>", "(I)V" }, |
/*35*/ { 24,"<init>", "(I)V" }, |
/*36 CIMQualifierNewI */ { /*CIMQualifier */26, "<init>", "(I)V" }, |
/*36*/ { 25,"<init>", "(I)V" }, |
/*37 CIMFlavorNewI */ { /*CIMFlavor */28, "<init>", "(I)V" }, |
/*37*/ { 26,"<init>", "(I)V" }, |
/*38 CIMFlavorGetFlavor */ { /*CIMFlavor */28, "getFlavor", "()I" }, |
/*38*/ { 28,"<init>", "(I)V" }, |
/*39 CIMArgumentCInst */ { /*CIMArgument */29, "cInst", "()I" }, |
/*38*/ { 28,"getFlavor", "()I" }, |
/*40 CIMArgumentNewI */ { /*CIMArgument */29, "<init>", "(I)V" }, |
/*39*/ { 29,"cInst", "()I" }, |
/*41 CIMExceptionNew */ { /*CIMException */13, "<init>", "()V" }, |
/*40*/ { 29,"<init>", "(I)V" }, |
/*42 CIMExceptionNewStOb */ { /*CIMException */13, "<init>", "(Ljava/lang/String;Ljava/lang/Object;)V" }, |
/*41*/ { 13,"<init>", "()V" }, |
/*43 CIMExceptionNewStObOb */ { /*CIMException */13, "<init>", "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)V" }, |
/*42*/ { 13,"<init>", "(Ljava/lang/String;)V" }, |
/*44 CIMExceptionNewStObObOb */ { /*CIMException */13, "<init>", "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V" }, |
/*43*/ { 13,"<init>", "(Ljava/lang/String;Ljava/lang/Object;)V" }, |
/*45 CIMValueNewI */ { /*CIMValue */19, "<init>", "(I)V" }, |
/*44*/ { 13,"<init>", "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)V" }, |
/*46 CIMObjectNewIZ */ { /*CIMObject */31, "<init>", "(IZ)V" }, |
/*45*/ { 13,"<init>", "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V" }, |
/*47 CharacterNewC */ { /*Character */32, "<init>", "(C)V" }, |
|
/*48 OperationContextNewI */ { /*OperationContext */33, "<init>", "(I)V" }, |
|
/*49 OperationContextUnassociate */ { /*OperationContext */33, "unassociate", "()V" }, |
|
/*50 ClassGetInterfaces */ { /*Class */34, "getInterfaces", "()[Ljava/lang/Class;" }, |
|
/*51 ClassGetName */ { /*Class */34, "getName", "()Ljava/lang/String;" }, |
}; | }; |
| |
const METHOD_STRUCT staticMethodNames[]={ | const METHOD_STRUCT staticMethodNames[]={ |
{ 14, "valueOf", "(J)Ljava/math/BigInteger;" }, |
/*00*/ { 14, "valueOf", "(J)Ljava/math/BigInteger;" }, |
{ 23, "load", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Class;" }, |
/*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(char*)]; |
jclass classRefs[sizeof(classNames)/sizeof(classNames[0])]; |
jmethodID instanceMethodIDs[sizeof(instanceMethodNames)/sizeof(METHOD_STRUCT)]; |
jmethodID instanceMethodIDs[sizeof(instanceMethodNames)/sizeof(instanceMethodNames[0])]; |
jmethodID staticMethodIDs[sizeof(staticMethodNames)/sizeof(METHOD_STRUCT)]; |
jmethodID staticMethodIDs[sizeof(staticMethodNames)/sizeof(staticMethodNames[0])]; |
| |
//static jclass providerClassRef; |
jclass JMPIjvm::getGlobalClassRef(JNIEnv *env, const char* name) |
|
{ |
jclass JMPIjvm::getGlobalClassRef(JNIEnv *env, const char* name) { |
|
jclass localRefCls=env->FindClass(name); | jclass localRefCls=env->FindClass(name); |
| |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getGlobalClassRef: localRefCls = "<<PEGASUS_STD(hex)<<(int)localRefCls<<PEGASUS_STD(dec)<<", name = "<<name<<PEGASUS_STD(endl)); |
|
|
|
if (localRefCls==NULL) | if (localRefCls==NULL) |
return JNI_FALSE; | return JNI_FALSE; |
| |
jclass globalRefCls=(jclass) env->NewGlobalRef(localRefCls); | jclass globalRefCls=(jclass) env->NewGlobalRef(localRefCls); |
| |
|
#if 0 |
|
jmethodID jmidToString = env->GetMethodID(globalRefCls, "toString", "()Ljava/lang/String;"); |
|
jstring jstringResult = (jstring)env->CallObjectMethod(globalRefCls, jmidToString); |
|
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)); |
|
|
|
env->ReleaseStringUTFChars (jstringResult, pszResult); |
|
#else |
|
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getGlobalClassRef: globalRefCls = "<<PEGASUS_STD(hex)<<(int)globalRefCls<<PEGASUS_STD(dec)<<", name = "<<name<<PEGASUS_STD(endl)); |
|
#endif |
|
|
env->DeleteLocalRef(localRefCls); | env->DeleteLocalRef(localRefCls); |
| |
return globalRefCls; | return globalRefCls; |
} | } |
| |
JMPIjvm::JMPIjvm() { |
JMPIjvm::JMPIjvm() |
|
{ |
initJVM(); | initJVM(); |
} | } |
| |
JMPIjvm::~JMPIjvm() { |
JMPIjvm::~JMPIjvm() |
|
{ |
} | } |
| |
int JMPIjvm::cacheIDs(JNIEnv *env) { |
int JMPIjvm::cacheIDs(JNIEnv *env) |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): enter"<<PEGASUS_STD(endl)); |
{ |
|
|
if (methodInitDone==1) | if (methodInitDone==1) |
return JNI_TRUE; | return JNI_TRUE; |
if (methodInitDone==-1) | if (methodInitDone==-1) |
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(char*)); i++) { |
for (unsigned i = 0; i<(sizeof(classNames)/sizeof(classNames[0])); i++) |
|
{ |
//////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<classNames[i]<<PEGASUS_STD(endl)); | //////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) |
{ | { |
|
|
} | } |
} | } |
| |
for (unsigned j=0; j<(sizeof(instanceMethodNames)/sizeof(METHOD_STRUCT)); j++) { |
for (unsigned j = 0; j<(sizeof(instanceMethodNames)/sizeof(instanceMethodNames[0])); j++) |
//////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<j<<": "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<PEGASUS_STD(endl)); |
{ |
|
//////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<j<<": "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<": "<<instanceMethodNames[j].signature<<PEGASUS_STD(endl)); |
if ((instanceMethodIDs[j]=env->GetMethodID(classRefs[instanceMethodNames[j].clsIndex], | if ((instanceMethodIDs[j]=env->GetMethodID(classRefs[instanceMethodNames[j].clsIndex], |
instanceMethodNames[j].methodName,instanceMethodNames[j].signature))==NULL) |
instanceMethodNames[j].methodName, |
|
instanceMethodNames[j].signature)) == NULL) |
{ | { |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error could not get method id for "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error could not get method id for "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<PEGASUS_STD(endl)); |
return 0; | return 0; |
} | } |
} | } |
| |
for (unsigned k=0; k<(sizeof(staticMethodNames)/sizeof(METHOD_STRUCT)); k++) { |
for (unsigned k = 0; k<(sizeof(staticMethodNames)/sizeof(staticMethodNames[0])); k++) |
//////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<k<<": "<<classNames[staticMethodNames[k].clsIndex]<<": "<<staticMethodNames[k].methodName<<PEGASUS_STD(endl)); |
{ |
|
//////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<k<<": "<<classNames[staticMethodNames[k].clsIndex]<<": "<<staticMethodNames[k].methodName<<": "<<staticMethodNames[k].signature<<PEGASUS_STD(endl)); |
if ((staticMethodIDs[k]=env->GetStaticMethodID(classRefs[staticMethodNames[k].clsIndex], | if ((staticMethodIDs[k]=env->GetStaticMethodID(classRefs[staticMethodNames[k].clsIndex], |
staticMethodNames[k].methodName,staticMethodNames[k].signature))==NULL) |
staticMethodNames[k].methodName, |
|
staticMethodNames[k].signature)) == NULL) |
{ | { |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error could not get method id for "<<classNames[staticMethodNames[k].clsIndex]<<": "<<staticMethodNames[k].methodName<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error could not get method id for "<<classNames[staticMethodNames[k].clsIndex]<<": "<<staticMethodNames[k].methodName<<PEGASUS_STD(endl)); |
return 0; | return 0; |
|
|
| |
DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): exit"<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): exit"<<PEGASUS_STD(endl)); |
| |
|
jv.env = env; |
|
jv.classRefs = classRefs; |
|
jv.instMethodIDs = instanceMethodIDs; |
|
jv.staticMethodIDs = staticMethodIDs; |
|
jv.instanceMethodNames = instanceMethodNames; |
|
|
methodInitDone=1; | methodInitDone=1; |
| |
return JNI_TRUE; | return JNI_TRUE; |
} | } |
| |
static void throwCIMException(JNIEnv *env,char *e) { |
static void throwCIMException(JNIEnv *env,char *e) |
env->ThrowNew(classRefs[13],e); |
{ |
|
JMPIjvm::cacheIDs(env); |
|
|
|
env->ThrowNew(JMPIjvm::jv.CIMExceptionClassRef,e); |
} | } |
| |
int JMPIjvm::destroyJVM() | int JMPIjvm::destroyJVM() |
|
|
DDD(PEGASUS_STD(cerr)<<"--- JPIjvm::destroyJVM()"<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cerr)<<"--- JPIjvm::destroyJVM()"<<PEGASUS_STD(endl)); |
| |
#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->DestroyJavaVM(); | jvm->DestroyJavaVM(); |
|
|
jvm=NULL; | jvm=NULL; |
|
|
return 0; | return 0; |
} | } |
#endif | #endif |
|
|
return -1; | return -1; |
} | } |
| |
|
Mutex JMPIjvm::_initMutex; |
|
|
int JMPIjvm::initJVM() | int JMPIjvm::initJVM() |
{ | { |
|
AutoMutex lock (_initMutex); |
|
|
|
if (jvm != NULL) |
|
{ |
|
return 0; |
|
} |
|
|
JavaVMInitArgs vm_args; | JavaVMInitArgs vm_args; |
jint res; | jint res; |
char *envstring; | char *envstring; |
JNIEnv *env; | JNIEnv *env; |
JavaVMOption *poptions = 0; | JavaVMOption *poptions = 0; |
int maxoption = 0; | int maxoption = 0; |
|
typedef struct _JVMOptions { |
|
const char *pszEnvName; |
|
const char *pszPrefix; |
|
bool fSplit; |
|
} JVMOPTIONS; |
Array<std::string> JNIoptions; | Array<std::string> JNIoptions; |
static const char *aENVoptions[][2] = { |
static JVMOPTIONS aEnvOptions[] = { |
{ "CLASSPATH", "-Djava.class.path=" }, |
{ "CLASSPATH", "-Djava.class.path=", false }, |
{ "PEGASUS_JMPI_MAX_HEAP", "-Xmx" }, |
{ "PEGASUS_JMPI_MAX_HEAP", "-Xmx" , false }, |
{ "PEGASUS_JMPI_INITIAL_HEAP", "-Xms" }, |
{ "PEGASUS_JMPI_INITIAL_HEAP", "-Xms" , false }, |
{ "PEGASUS_JMPI_JAVA_THREAD_STACK_SIZE", "-Xss" } |
{ "PEGASUS_JMPI_JAVA_THREAD_STACK_SIZE", "-Xss" , false }, |
|
{ "PEGASUS_JMPI_VERBOSE", "-verbose:" , true } |
}; | }; |
std::ostringstream oss; | std::ostringstream oss; |
| |
#ifdef PEGASUS_DEBUG | #ifdef PEGASUS_DEBUG |
if (getenv("PEGASUS_JMPI_TRACE")) JMPIjvm::trace=1; |
if (getenv("PEGASUS_JMPI_TRACE")) |
else JMPIjvm::trace=0; |
JMPIjvm::trace = 1; |
|
else |
|
JMPIjvm::trace = 0; |
#else | #else |
JMPIjvm::trace=0; | JMPIjvm::trace=0; |
#endif | #endif |
|
|
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)); | DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): No CLASSPATH environment variable found" << PEGASUS_STD(endl)); |
| |
|
#ifdef PEGASUS_PLATFORM_ZOS_ZSERIES_IBM |
|
throw PEGASUS_CIM_EXCEPTION_L( |
|
CIM_ERR_FAILED, |
|
MessageLoaderParms( |
|
"ProviderManager2.JMPI.GET_CLASSPATH_FAILED.PEGASUS_OS_ZOS", |
|
"Could not get CLASSPATH from environment." |
|
" Either CLASSPATH is longer than 255 characters" |
|
" or not set at all.") |
|
); |
|
#else |
|
throw PEGASUS_CIM_EXCEPTION_L( |
|
CIM_ERR_FAILED, |
|
MessageLoaderParms( |
|
"ProviderManager2.JMPI.GET_CLASSPATH_FAILED.STANDARD", |
|
"Could not get CLASSPATH from environment.") |
|
); |
|
#endif |
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++) |
for (Uint32 i = 0; i < (int)(sizeof (aEnvOptions)/sizeof (aEnvOptions[0])); i++) |
{ | { |
const char *name = aENVoptions[i][0]; |
JVMOPTIONS *pEnvOption = &aEnvOptions[i]; |
| |
envstring = getenv (name); |
envstring = getenv (pEnvOption->pszEnvName); |
if (envstring) | if (envstring) |
{ | { |
|
if (pEnvOption->fSplit) |
|
{ |
|
bool fCommaFound = true; |
|
string stringValues = envstring; |
|
string::size_type posStart = 0; |
|
string::size_type posEnd = stringValues.length () - 1; |
|
|
|
while (fCommaFound) |
|
{ |
|
string stringValue; |
|
string::size_type posComma = stringValues.find (',', posStart); |
|
|
|
if (posComma != string::npos) |
|
{ |
|
fCommaFound = true; |
|
stringValue = stringValues.substr (posStart, posComma); |
|
posStart = posComma + 1; |
|
} |
|
else |
|
{ |
|
fCommaFound = false; |
|
stringValue = stringValues.substr (posStart, posEnd - posStart + 1); |
|
} |
|
|
|
DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): fCommaFound = " << fCommaFound << ", posStart = " << posStart << ", posComma = " << posComma << ", posEnd = " << posEnd << "" << PEGASUS_STD(endl)); |
|
|
|
maxoption++; |
|
|
|
oss.str (""); |
|
oss << pEnvOption->pszPrefix << stringValue; |
|
|
|
JNIoptions.append (oss.str ()); |
|
|
|
DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): " << pEnvOption->pszEnvName << " found! Specifying \"" << oss.str () << "\"" << PEGASUS_STD(endl)); |
|
} |
|
} |
|
else |
|
{ |
maxoption++; | maxoption++; |
| |
oss.str (""); | oss.str (""); |
oss << aENVoptions[i][1] << envstring; |
oss << pEnvOption->pszPrefix << envstring; |
| |
JNIoptions.append (oss.str ()); | JNIoptions.append (oss.str ()); |
| |
DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): " << name << " found! Specifying \"" << oss.str () << "\"" << PEGASUS_STD(endl)); |
DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): " << pEnvOption->pszEnvName << " found! Specifying \"" << oss.str () << "\"" << PEGASUS_STD(endl)); |
|
} |
} | } |
} | } |
| |
|
|
DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): Setting option " << i << " to \"" << poptions[i].optionString << "\"" << PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): Setting option " << i << " to \"" << poptions[i].optionString << "\"" << PEGASUS_STD(endl)); |
} | } |
| |
vm_args.version=0x00010002; |
vm_args.version = JNI_VERSION_1_2; |
vm_args.options=poptions; | vm_args.options=poptions; |
vm_args.nOptions=maxoption; | vm_args.nOptions=maxoption; |
vm_args.ignoreUnrecognized=JNI_TRUE; | vm_args.ignoreUnrecognized=JNI_TRUE; |
|
|
free (poptions); | free (poptions); |
} | } |
| |
if (res!=0) { |
if (res!= 0) |
|
{ |
|
jv.initRc = 1; |
|
|
DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): Can not create Java VM"<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): Can not create Java VM"<<PEGASUS_STD(endl)); |
| |
exit(1); |
return -1; |
} | } |
jv.jvm=jvm; |
|
jv.env=env; |
|
| |
if (cacheIDs(env)==1) { |
cacheIDs(env); |
jv.classRefs=classRefs; |
|
jv.instMethodIDs=instanceMethodIDs; |
if (env->ExceptionOccurred()) |
} |
{ |
|
jv.initRc = 1; |
| |
if (env->ExceptionOccurred()) { |
|
env->ExceptionDescribe(); | env->ExceptionDescribe(); |
exit(1); |
|
|
#ifdef JAVA_DESTROY_VM_WORKS |
|
|
|
JvmVector *jv = NULL; |
|
|
|
attachThread (&jv); |
|
|
|
jvm->DestroyJavaVM (); |
|
|
|
jvm = NULL; |
|
#endif |
|
|
|
return -1; |
} | } |
| |
|
jv.initRc = 1; |
|
jv.jvm = jvm; |
|
|
return res; | return res; |
} | } |
| |
JNIEnv* JMPIjvm::attachThread(JvmVector **jvp) { |
JNIEnv* JMPIjvm::attachThread(JvmVector **jvp) |
JNIEnv* env; |
{ |
if (jvm==NULL) initJVM(); |
JNIEnv* env = NULL; |
|
int rc; |
|
|
|
if (jvm == NULL) |
|
{ |
|
rc = initJVM (); |
|
|
|
if ((jvm == NULL) || (rc != 0)) |
|
return NULL; |
|
} |
|
|
jvm->AttachCurrentThread((void**)&env,NULL); | jvm->AttachCurrentThread((void**)&env,NULL); |
|
|
*jvp=&jv; | *jvp=&jv; |
|
|
return env; | return env; |
} | } |
| |
void JMPIjvm::detachThread() { |
void JMPIjvm::detachThread() |
|
{ |
jvm->DetachCurrentThread(); | jvm->DetachCurrentThread(); |
} | } |
| |
|
|
_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)); | DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(int)gProv<<", scls = "<<(int)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
| |
if (gProv) { |
if (gProv) |
|
{ |
*cls=scls; | *cls=scls; |
return gProv; | return gProv; |
} | } |
|
|
jstring jjar=env->NewStringUTF((const char*)jar.getCString()); | jstring jjar=env->NewStringUTF((const char*)jar.getCString()); |
jstring jcln=env->NewStringUTF((const char*)cln.getCString()); | jstring jcln=env->NewStringUTF((const char*)cln.getCString()); |
| |
jclass jcls=(jclass)env->CallStaticObjectMethod(classRefs[23],staticMethodIDs[1], |
jclass jcls = (jclass)env->CallStaticObjectMethod (JMPIjvm::jv.JarClassLoaderRef, |
jjar,jcln); |
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); | PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<cn<<PEGASUS_STD(endl); |
////////return NULL; | ////////return NULL; |
|
|
*/ | */ |
| |
scls=getGlobalClassRef(env,(const char*)cln.getCString()); | scls=getGlobalClassRef(env,(const char*)cln.getCString()); |
if (env->ExceptionCheck()) { |
if (env->ExceptionCheck()) |
|
{ |
DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::getProvider: Provider "<<cn<<" not found"<<PEGASUS_STD(endl)); | DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::getProvider: Provider "<<cn<<" not found"<<PEGASUS_STD(endl)); |
DDD(env->ExceptionDescribe()); | DDD(env->ExceptionDescribe()); |
| |
|
|
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)); | DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<cn<<PEGASUS_STD(endl)); |
return NULL; | return NULL; |
} | } |
|
|
_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)); | DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(int)gProv<<", scls = "<<(int)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl)); |
| |
if (gProv) { |
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(PEGASUS_STD(cerr)<<"--- JMPIjvm::getProvider: Provider "<<cn<<" not found"<<PEGASUS_STD(endl)); |
DDD(env->ExceptionDescribe()); | DDD(env->ExceptionDescribe()); |
| |
|
|
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)); | DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<cn<<PEGASUS_STD(endl)); |
return NULL; | return NULL; |
} | } |
|
|
| |
void JMPIjvm::checkException(JNIEnv *env) | void JMPIjvm::checkException(JNIEnv *env) |
{ | { |
if (env->ExceptionCheck()) { |
if (env->ExceptionCheck ()) |
jstring jMsg=NULL,jId=NULL; |
{ |
|
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::EMPTY, |
|
id = String::EMPTY; |
jthrowable err=env->ExceptionOccurred(); | jthrowable err=env->ExceptionOccurred(); |
|
|
DDD(env->ExceptionDescribe()); | DDD(env->ExceptionDescribe()); |
if (env->IsInstanceOf(err,JMPIjvm::jv.CIMExceptionClassRef)) { |
|
|
if (env->IsInstanceOf (err, JMPIjvm::jv.CIMExceptionClassRef)) |
|
{ |
env->ExceptionClear(); | env->ExceptionClear(); |
if (err) { |
if (err) |
|
{ |
jMsg=(jstring)env->CallObjectMethod(err,JMPIjvm::jv.ThrowableGetMessage); | jMsg=(jstring)env->CallObjectMethod(err,JMPIjvm::jv.ThrowableGetMessage); |
code=(int)env->CallIntMethod(err,JMPIjvm::jv.CIMExceptionGetCode); | code=(int)env->CallIntMethod(err,JMPIjvm::jv.CIMExceptionGetCode); |
jId=(jstring)env->CallObjectMethod(err,JMPIjvm::jv.CIMExceptionGetID); | jId=(jstring)env->CallObjectMethod(err,JMPIjvm::jv.CIMExceptionGetID); |
if (jId) { |
|
|
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); |
|
|
throw CIMException((CIMStatusCode)code,id+" ("+msg+")"); | throw CIMException((CIMStatusCode)code,id+" ("+msg+")"); |
} | } |
} | } |
else { |
else |
|
{ |
|
DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::checkException: exiting..."<<PEGASUS_STD(endl)); |
env->ExceptionDescribe(); | env->ExceptionDescribe(); |
exit(13); | exit(13); |
} | } |
|
|
| |
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 pl; |
| |
|
if (l) |
|
{ |
|
Array<CIMName> n; |
| |
extern "C" { |
for (jsize i = 0, s = jEnv->GetArrayLength (l); i <s; i++) |
|
{ |
|
jstring jObj = (jstring)jEnv->GetObjectArrayElement (l, i); |
|
const char *pn = jEnv->GetStringUTFChars (jObj, NULL); |
|
|
|
n.append (pn); |
|
|
|
jEnv->ReleaseStringUTFChars (jObj, pn); |
|
} |
|
|
|
pl.set (n); |
|
} |
|
|
|
return pl; |
|
} |
| |
|
extern "C" { |
| |
void throwCimException(JNIEnv *jEnv, CIMException & e) { |
void throwCimException (JNIEnv *jEnv, CIMException &e) |
|
{ |
JMPIjvm::cacheIDs(jEnv); | JMPIjvm::cacheIDs(jEnv); |
jobject ev=jEnv->NewObject(classRefs[13],instanceMethodIDs[18],(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(classRefs[13],instanceMethodIDs[18],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(classRefs[13],instanceMethodIDs[18],7); |
jobject ev = jEnv->NewObject(JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewI,7); |
jEnv->Throw((jthrowable)ev); | jEnv->Throw((jthrowable)ev); |
} | } |
| |
| |
|
|
|
|
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
// - CIMException | // - CIMException |
|
|
// ------------------------------------- | // ------------------------------------- |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1new | JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1new |
(JNIEnv *jEnv, jobject jThs) { |
(JNIEnv *jEnv, jobject jThs) |
jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[41]); |
{ |
|
JMPIjvm::cacheIDs(jEnv); |
|
jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNew); |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newS | JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newS |
(JNIEnv *jEnv, jobject jThs, jstring jM) { |
(JNIEnv *jEnv, jobject jThs, jstring jM) |
jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[42],jM); |
{ |
|
JMPIjvm::cacheIDs(jEnv); |
|
jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewSt,jM); |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSO | JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSO |
(JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1) { |
(JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1) |
jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[43],jM,jO1); |
{ |
|
JMPIjvm::cacheIDs(jEnv); |
|
jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewStOb,jM,jO1); |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSOO | JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSOO |
(JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1, jobject jO2) { |
(JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1, jobject jO2) |
jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[44],jM,jO1,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 | JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSOOO |
(JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1, jobject jO2, jobject jO3) { |
(JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1, jobject jO2, jobject jO3) |
jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[45],jM,jO1,jO2,jO3); |
{ |
|
JMPIjvm::cacheIDs(jEnv); |
|
jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewStObObOb,jM,jO1,jO2,jO3); |
} | } |
| |
| |
|
|
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
CIMPropertyList getList(JNIEnv *jEnv, jobjectArray l) { |
|
CIMPropertyList pl; |
|
if (l) { |
|
Array<CIMName> n; |
|
for (jsize i=0,s=jEnv->GetArrayLength(l); i<s; i++) { |
|
jstring jObj=(jstring)jEnv->GetObjectArrayElement(l,i); |
|
const char *pn=jEnv->GetStringUTFChars(jObj,NULL); |
|
n.append(pn); |
|
jEnv->ReleaseStringUTFChars(jObj,pn); |
|
} |
|
pl.set(n); |
|
} |
|
return pl; |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getClass | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getClass |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean lo, | (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean lo, |
jboolean iq, jboolean ic, jobjectArray jPl) | jboolean iq, jboolean ic, jobjectArray jPl) |
|
|
pl=CIMPropertyList(); | pl=CIMPropertyList(); |
| |
try { | try { |
CIMClass cls=ch->getClass(ctx,cop->getNameSpace(), |
CIMClass cls = ch->getClass (ctx, |
|
cop->getNameSpace (), |
cop->getClassName(), | cop->getClassName(), |
(Boolean)lo, | (Boolean)lo, |
(Boolean)iq, | (Boolean)iq, |
|
|
OperationContext ctx; | OperationContext ctx; |
| |
try { | try { |
ch->createClass(ctx,cop->getNameSpace(),*cl); |
ch->createClass (ctx, |
|
cop->getNameSpace (), |
|
*cl); |
} | } |
Catch(jEnv); | Catch(jEnv); |
} | } |
|
|
OperationContext ctx; | OperationContext ctx; |
| |
try { | try { |
ch->modifyClass(ctx,cop->getNameSpace(),*cl); |
ch->modifyClass (ctx, |
|
cop->getNameSpace (), |
|
*cl); |
} | } |
Catch(jEnv); | Catch(jEnv); |
} | } |
|
|
OperationContext ctx; | OperationContext ctx; |
| |
try { | try { |
ch->deleteClass(ctx,cop->getNameSpace(),cop->getClassName()); |
ch->deleteClass (ctx, |
|
cop->getNameSpace (), |
|
cop->getClassName ()); |
} | } |
Catch(jEnv); | Catch(jEnv); |
} | } |
|
|
OperationContext ctx; | OperationContext ctx; |
| |
try { | try { |
Array<CIMName> enm = ch->enumerateClassNames(ctx,cop->getNameSpace(),cop->getClassName(),deep); |
Array<CIMName> enm = ch->enumerateClassNames (ctx, |
|
cop->getNameSpace (), |
|
cop->getClassName (), |
|
(Boolean)deep); |
Array<CIMObjectPath> *enmop = new Array<CIMObjectPath>(); | Array<CIMObjectPath> *enmop = new Array<CIMObjectPath>(); |
| |
for (int i=0,m=enm.size(); i<m; i++) { |
for (int i = 0, m = enm.size (); i < m; i++) |
enmop->append(CIMObjectPath(String::EMPTY,ns,enm[i])); |
{ |
|
enmop->append (CIMObjectPath (String::EMPTY, |
|
ns, |
|
enm[i])); |
} | } |
| |
return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, enmop); | return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, enmop); |
|
|
Array<CIMClass> en=ch->enumerateClasses(ctx, | Array<CIMClass> en=ch->enumerateClasses(ctx, |
cop->getNameSpace(), | cop->getNameSpace(), |
cop->getClassName(), | cop->getClassName(), |
deep, |
(Boolean)deep, |
(Boolean)lo, | (Boolean)lo, |
iq, |
(Boolean)iq, |
ic); |
(Boolean)ic); |
| |
return DEBUG_ConvertCToJava (Array<CIMClass>*, jint, new Array<CIMClass>(en)); | return DEBUG_ConvertCToJava (Array<CIMClass>*, jint, new Array<CIMClass>(en)); |
} | } |
|
|
(Boolean)iq, | (Boolean)iq, |
(Boolean)ic, | (Boolean)ic, |
pl)); | pl)); |
|
|
return DEBUG_ConvertCToJava (CIMInstance*, jint, inst); | return DEBUG_ConvertCToJava (CIMInstance*, jint, inst); |
} | } |
Catch(jEnv); | Catch(jEnv); |
| |
return -1; |
return 0; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance | JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance |
|
|
try { | try { |
ci->setPath(*cop); | ci->setPath(*cop); |
| |
CIMObjectPath obj=ch->createInstance(ctx,cop->getNameSpace(),*ci); |
CIMObjectPath obj = ch->createInstance (ctx, |
|
cop->getNameSpace (), |
|
*ci); |
| |
return DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(obj)); | return DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(obj)); |
} | } |
|
|
| |
try { | try { |
ci->setPath(*cop); | ci->setPath(*cop); |
ch->modifyInstance(ctx,cop->getNameSpace(),*ci,(Boolean)iq,pl); |
ch->modifyInstance (ctx, |
|
cop->getNameSpace (), |
|
*ci, |
|
(Boolean)iq, |
|
pl); |
} | } |
Catch(jEnv); | Catch(jEnv); |
} | } |
|
|
Array<CIMInstance> en=ch->enumerateInstances(ctx, | Array<CIMInstance> en=ch->enumerateInstances(ctx, |
cop->getNameSpace(), | cop->getNameSpace(), |
cop->getClassName(), | cop->getClassName(), |
deep, |
(Boolean)deep, |
lo, |
(Boolean)lo, |
iq, |
(Boolean)iq, |
ic, |
(Boolean)ic, |
pl); | pl); |
|
|
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, new Array<CIMInstance>(en)); | return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, new Array<CIMInstance>(en)); |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
|
String query(str); | String query(str); |
| |
jEnv->ReleaseStringUTFChars(jQuery,str); | jEnv->ReleaseStringUTFChars(jQuery,str); |
|
|
str=jEnv->GetStringUTFChars(jQl,NULL); | str=jEnv->GetStringUTFChars(jQl,NULL); |
| |
String ql(str); | String ql(str); |
|
|
jEnv->ReleaseStringUTFChars(jQl,str); | jEnv->ReleaseStringUTFChars(jQl,str); |
| |
try { | try { |
Array<CIMObject> enm=ch->execQuery(ctx,cop->getNameSpace(),ql,query); |
Array<CIMObject> enm = ch->execQuery (ctx, |
|
cop->getNameSpace (), |
|
ql, |
|
query); |
Array<CIMInstance> *enmInst=new Array<CIMInstance>(); | Array<CIMInstance> *enmInst=new Array<CIMInstance>(); |
| |
for (int i=0,m=enm.size(); i<m; i++) { |
for (int i = 0,m = enm.size (); i<m; i++) |
|
{ |
enmInst->append(CIMInstance(enm[i])); | enmInst->append(CIMInstance(enm[i])); |
} | } |
| |
|
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); | CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
OperationContext ctx; | OperationContext ctx; |
const char *str = jEnv->GetStringUTFChars(jN,NULL); | const char *str = jEnv->GetStringUTFChars(jN,NULL); |
|
|
try { |
|
CIMName prop(str); | CIMName prop(str); |
CIMValue *cv = new CIMValue(ch->getProperty(ctx, cop->getNameSpace(),*cop,prop)); |
|
jEnv->ReleaseStringUTFChars(jN,str); | jEnv->ReleaseStringUTFChars(jN,str); |
| |
|
try { |
|
CIMValue *cv = new CIMValue (ch->getProperty (ctx, |
|
cop->getNameSpace (), |
|
*cop, |
|
prop)); |
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); | return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
} | } |
Catch(jEnv); | Catch(jEnv); |
| |
return -1; |
return 0; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setProperty | JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setProperty |
|
|
CIMName pName(str); | CIMName pName(str); |
| |
jEnv->ReleaseStringUTFChars(jPn,str); | jEnv->ReleaseStringUTFChars(jPn,str); |
|
|
try { | try { |
ch->setProperty(ctx,cop->getNameSpace(),*cop,pName,*val); |
ch->setProperty (ctx, |
|
cop->getNameSpace (), |
|
*cop, |
|
pName, |
|
*val); |
} | } |
Catch(jEnv); | Catch(jEnv); |
} | } |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jMn, jobject jIn, jobject jOut) | (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jMn, jobject jIn, jobject jOut) |
{ | { |
|
JMPIjvm::cacheIDs (jEnv); |
|
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); | CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); | CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
OperationContext ctx; | OperationContext ctx; |
|
|
Array<CIMParamValue> in; | Array<CIMParamValue> in; |
Array<CIMParamValue> out; | Array<CIMParamValue> out; |
| |
for (int i=0,m=jEnv->CallIntMethod(jIn,instanceMethodIDs[28]); i<m; i++) { |
for (int i = 0, m = jEnv->CallIntMethod (jIn,JMPIjvm::jv.VectorSize); i < m; i++) |
|
{ |
JMPIjvm::checkException(jEnv); | JMPIjvm::checkException(jEnv); |
| |
jobject jProp=jEnv->CallObjectMethod(jIn,instanceMethodIDs[16],i); |
jobject jProp = jEnv->CallObjectMethod (jIn,JMPIjvm::jv.VectorElementAt,i); |
|
|
JMPIjvm::checkException(jEnv); | JMPIjvm::checkException(jEnv); |
| |
jint jp = jEnv->CallIntMethod(jProp,instanceMethodIDs[29]); |
jint jp = jEnv->CallIntMethod (jProp,JMPIjvm::jv.CIMPropertyCInst); |
CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp); | CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp); |
| |
JMPIjvm::checkException(jEnv); | JMPIjvm::checkException(jEnv); |
|
|
in.append(CIMParamValue(p->getName().getString(),p->getValue())); | in.append(CIMParamValue(p->getName().getString(),p->getValue())); |
} | } |
try { | try { |
CIMValue *val=new CIMValue(ch->invokeMethod(ctx,cop->getNameSpace(),*cop,method,in,out)); |
CIMValue *val = new CIMValue (ch->invokeMethod (ctx, |
|
cop->getNameSpace (), |
|
*cop, |
|
method, |
|
in, |
|
out)); |
| |
for (int i=0,m=out.size(); i<m; i++) { |
for (int i = 0,m = out.size (); i<m; i++) |
|
{ |
const CIMParamValue &parm = out[i]; | const CIMParamValue &parm = out[i]; |
const CIMValue v = parm.getValue(); | const CIMValue v = parm.getValue(); |
CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize()); |
CIMProperty *p = new CIMProperty (parm.getParameterName (), |
|
v, |
|
v.getArraySize ()); |
jint jp = DEBUG_ConvertCToJava (CIMProperty*, jint, p); | jint jp = DEBUG_ConvertCToJava (CIMProperty*, jint, p); |
jobject prop = jEnv->NewObject(classRefs[15],instanceMethodIDs[14],jp); |
jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef, |
|
JMPIjvm::jv.CIMPropertyNewI, |
|
jp); |
| |
jEnv->CallVoidMethod(jOut,instanceMethodIDs[15],prop); |
jEnv->CallVoidMethod (jOut, JMPIjvm::jv.VectorAddElement, prop); |
} | } |
return DEBUG_ConvertCToJava (CIMValue*, jint, val); | return DEBUG_ConvertCToJava (CIMValue*, jint, val); |
} | } |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod24 | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod24 |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jMn, | (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jMn, |
jobjectArray jIn, jobjectArray jOut) | jobjectArray jIn, jobjectArray jOut) |
|
|
{ | { |
|
JMPIjvm::cacheIDs (jEnv); |
|
|
CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); | CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); | CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
OperationContext ctx; | OperationContext ctx; |
|
|
Array<CIMParamValue> in; | Array<CIMParamValue> in; |
Array<CIMParamValue> out; | Array<CIMParamValue> out; |
| |
for (int i=0,m=jEnv->GetArrayLength(jIn); i<m; i++) { |
if (jIn) |
|
{ |
|
for (int i = 0, m = jEnv->GetArrayLength (jIn); i < m; i++) |
|
{ |
JMPIjvm::checkException(jEnv); | JMPIjvm::checkException(jEnv); |
| |
jobject jArg=jEnv->GetObjectArrayElement(jIn,i); | jobject jArg=jEnv->GetObjectArrayElement(jIn,i); |
|
|
JMPIjvm::checkException(jEnv); | JMPIjvm::checkException(jEnv); |
| |
jint jp = jEnv->CallIntMethod(jArg,instanceMethodIDs[39]); |
jint jp = jEnv->CallIntMethod (jArg,JMPIjvm::jv.CIMArgumentCInst); |
CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jp); | CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jp); |
| |
JMPIjvm::checkException(jEnv); | JMPIjvm::checkException(jEnv); |
| |
in.append(*p); | in.append(*p); |
} | } |
|
} |
try { | try { |
CIMValue *val=new CIMValue(ch->invokeMethod(ctx,cop->getNameSpace(),*cop,method,in,out)); |
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++) { |
if (jOut) |
const CIMParamValue &parm = out[i]; |
{ |
jint jParm = DEBUG_ConvertCToJava (const CIMParamValue*, jint, &parm); |
for (int i = 0, m = out.size (), o = jEnv->GetArrayLength (jOut); i < m && i< o; i++) |
|
{ |
|
CIMParamValue *parm = new CIMParamValue (out[i]); |
|
jint jParm = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm); |
| |
jEnv->SetObjectArrayElement(jOut,i, | jEnv->SetObjectArrayElement(jOut,i, |
jEnv->NewObject(classRefs[29],instanceMethodIDs[40],jParm)); |
jEnv->NewObject (JMPIjvm::jv.CIMArgumentClassRef,JMPIjvm::jv.CIMArgumentNewI,jParm)); |
|
} |
} | } |
return DEBUG_ConvertCToJava (CIMValue*, jint, val); | return DEBUG_ConvertCToJava (CIMValue*, jint, val); |
} | } |
|
|
OperationContext ctx; | OperationContext ctx; |
const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); | const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); |
| |
CIMName assocClass(str); |
CIMName assocClass; |
jEnv->ReleaseStringUTFChars(jAssocClass,str); |
|
str=jEnv->GetStringUTFChars(jResultClass,NULL); |
|
CIMName resultClass(str); |
|
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 { |
if ( str |
Array<CIMObjectPath> enm=ch->associatorNames(ctx, |
&& *str |
cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole); |
) |
return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm)); |
{ |
|
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>*, jint, new Array<CIMObjectPath> (enm)); |
} | } |
Catch(jEnv); | Catch(jEnv); |
| |
return 0; | return 0; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIM__1associators |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associators |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, | (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, |
jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole, | jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole, |
jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl) | jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl) |
|
|
OperationContext ctx; | OperationContext ctx; |
CIMPropertyList pl = getList(jEnv,jPl); | CIMPropertyList pl = getList(jEnv,jPl); |
const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); | 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; |
|
} |
|
} |
| |
CIMName assocClass(str); |
|
jEnv->ReleaseStringUTFChars(jAssocClass,str); | jEnv->ReleaseStringUTFChars(jAssocClass,str); |
|
|
str=jEnv->GetStringUTFChars(jResultClass,NULL); | str=jEnv->GetStringUTFChars(jResultClass,NULL); |
CIMName resultClass(str); |
|
|
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); | jEnv->ReleaseStringUTFChars(jResultClass,str); |
|
|
str=jEnv->GetStringUTFChars(jRole,NULL); | str=jEnv->GetStringUTFChars(jRole,NULL); |
|
|
String role(str); | String role(str); |
|
|
jEnv->ReleaseStringUTFChars(jRole,str); | jEnv->ReleaseStringUTFChars(jRole,str); |
|
|
str=jEnv->GetStringUTFChars(jResultRole,NULL); | str=jEnv->GetStringUTFChars(jResultRole,NULL); |
|
|
String resultRole(str); | String resultRole(str); |
|
|
jEnv->ReleaseStringUTFChars(jResultRole,str); | jEnv->ReleaseStringUTFChars(jResultRole,str); |
| |
try { | try { |
Array<CIMObject> enm=ch->associators(ctx, | Array<CIMObject> enm=ch->associators(ctx, |
cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole, |
cop->getNameSpace (), |
(Boolean)includeQualifiers,(Boolean)includeClassOrigin,pl); |
*cop, |
|
assocClass, |
|
resultClass, |
|
role, |
|
resultRole, |
|
(Boolean)includeQualifiers, |
|
(Boolean)includeClassOrigin, |
|
pl); |
Array<CIMInstance> *enmInst=new Array<CIMInstance>(); | Array<CIMInstance> *enmInst=new Array<CIMInstance>(); |
for (int i=0,m=enm.size(); i<m; i++) { |
|
|
for (int i = 0,m = enm.size (); i<m; i++) |
|
{ |
enmInst->append(CIMInstance(enm[i])); | enmInst->append(CIMInstance(enm[i])); |
} | } |
|
|
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst); | return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst); |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); | CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
OperationContext ctx; | OperationContext ctx; |
const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); | 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; |
|
} |
|
} |
| |
CIMName assocClass(str); |
|
jEnv->ReleaseStringUTFChars(jAssocClass,str); | jEnv->ReleaseStringUTFChars(jAssocClass,str); |
|
|
str=jEnv->GetStringUTFChars(jRole,NULL); | str=jEnv->GetStringUTFChars(jRole,NULL); |
|
|
String role(str); | String role(str); |
|
|
jEnv->ReleaseStringUTFChars(jRole,str); | jEnv->ReleaseStringUTFChars(jRole,str); |
| |
try { | try { |
Array<CIMObjectPath> enm=ch->referenceNames(ctx, | Array<CIMObjectPath> enm=ch->referenceNames(ctx, |
cop->getNameSpace(),*cop,assocClass,role); |
cop->getNameSpace (), |
|
*cop, |
|
assocClass, |
|
role); |
|
|
return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm)); | return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm)); |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
|
OperationContext ctx; | OperationContext ctx; |
CIMPropertyList pl = getList(jEnv,jPl); | CIMPropertyList pl = getList(jEnv,jPl); |
const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); | const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); |
CIMName assocClass(str); |
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); | jEnv->ReleaseStringUTFChars(jAssocClass,str); |
|
|
str=jEnv->GetStringUTFChars(jRole,NULL); | str=jEnv->GetStringUTFChars(jRole,NULL); |
| |
String role(str); | String role(str); |
|
|
| |
try { | try { |
Array<CIMObject> enm=ch->references(ctx, | Array<CIMObject> enm=ch->references(ctx, |
cop->getNameSpace(),*cop,assocClass,role, |
cop->getNameSpace (), |
(Boolean)includeQualifiers,(Boolean)includeClassOrigin,pl); |
*cop, |
|
assocClass, |
|
role, |
|
(Boolean)includeQualifiers, |
|
(Boolean)includeClassOrigin, |
|
pl); |
Array<CIMInstance> *enmInst=new Array<CIMInstance>(); | Array<CIMInstance> *enmInst=new Array<CIMInstance>(); |
for (int i=0,m=enm.size(); i<m; i++) { |
|
|
for (int i = 0, m = enm.size (); i < m; i++) |
|
{ |
enmInst->append(CIMInstance(enm[i])); | enmInst->append(CIMInstance(enm[i])); |
} | } |
|
|
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst); | return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst); |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
|
String name(str); | String name(str); |
| |
jEnv->ReleaseStringUTFChars(jName,str); | jEnv->ReleaseStringUTFChars(jName,str); |
|
|
str=jEnv->GetStringUTFChars(jNs,NULL); | str=jEnv->GetStringUTFChars(jNs,NULL); |
| |
String ns(str); | String ns(str); |
| |
jEnv->ReleaseStringUTFChars(jNs,str); | jEnv->ReleaseStringUTFChars(jNs,str); |
| |
CIMObjectPath ref(CIMObjectPath(ind->getPath())); |
CIMObjectPath ref (ind->getPath ()); |
| |
ref.setNameSpace(ns); | 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); | ind->setPath(ref); |
|
DDD (PEGASUS_STD (cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent () ind = "<<ind->getPath ().toString ()<<PEGASUS_STD (endl)); |
| |
JMPIProviderManager::indProvRecord *prec; |
JMPIProviderManager::indProvRecord *prec = NULL; |
OperationContext* context; |
String sPathString = ind->getPath ().toString (); |
|
OperationContext *context = NULL; |
|
bool fResult = false; |
| |
if (JMPIProviderManager::provTab.lookup(name,prec)) { |
{ |
if (prec->enabled) { |
AutoMutex lock (JMPIProviderManager::mutexProvTab); |
context=prec->ctx; |
|
try { |
fResult = JMPIProviderManager::provTab.lookup (name, prec); |
prec->handler->deliver(*context, *ind); |
|
|
DDD (PEGASUS_STD (cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent () fResult = "<<fResult<<", name = "<<name<<PEGASUS_STD (endl)); |
|
} |
|
|
|
if (fResult) |
|
{ |
|
if (prec->enabled) |
|
{ |
|
try |
|
{ |
|
prec->handler->deliver (*prec->ctx, *ind); |
} | } |
Catch(jEnv); | Catch(jEnv); |
} | } |
} | } |
else { |
else |
DDD(PEGASUS_STD(cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent() "<<name<<" not found"<<PEGASUS_STD(endl)); |
{ |
|
DDD (PEGASUS_STD (cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent () provider name \""<<name<<"\" not found"<<PEGASUS_STD (endl)); |
} | } |
} | } |
| |
|
|
try { | try { |
CIMInstance *ci=new CIMInstance(cls->getClassName()); | CIMInstance *ci=new CIMInstance(cls->getClassName()); |
| |
for (int i=0,m=cls->getQualifierCount(); i<m; i++) { |
for (int i = 0, m = cls->getQualifierCount (); i < m; i++) |
|
{ |
try { | try { |
ci->addQualifier(cls->getQualifier(i).clone()); | ci->addQualifier(cls->getQualifier(i).clone()); |
} | } |
catch (Exception e) {} | catch (Exception e) {} |
} | } |
for (int i=0,m=cls->getPropertyCount(); i<m; i++) { |
for (int i = 0, m = cls->getPropertyCount (); i < m; i++) |
|
{ |
CIMProperty cp= cls->getProperty(i); | CIMProperty cp= cls->getProperty(i); |
|
|
ci->addProperty(cp.clone()); | ci->addProperty(cp.clone()); |
for (int j=0, s=cp.getQualifierCount(); j<s; j++) { |
|
|
for (int j = 0, s = cp.getQualifierCount (); j < s; j++) |
|
{ |
try { | try { |
ci->getProperty(i).addQualifier(cp.getQualifier(j)); | ci->getProperty(i).addQualifier(cp.getQualifier(j)); |
} | } |
catch (Exception e) {} | catch (Exception e) {} |
} | } |
} | } |
|
|
return DEBUG_ConvertCToJava (CIMInstance*, jint, ci); | return DEBUG_ConvertCToJava (CIMInstance*, jint, ci); |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
|
{ | { |
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); | CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
const char *str = jEnv->GetStringUTFChars(jN,NULL); | const char *str = jEnv->GetStringUTFChars(jN,NULL); |
jint rv = -1; |
jint rv = 0; |
Uint32 pos = cls->findQualifier(String(str)); | Uint32 pos = cls->findQualifier(String(str)); |
| |
if (pos!=PEG_NOT_FOUND) | if (pos!=PEG_NOT_FOUND) |
|
|
{ | { |
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); | CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
const char *str = jEnv->GetStringUTFChars(jN,NULL); | const char *str = jEnv->GetStringUTFChars(jN,NULL); |
jint rv = -1; |
jint rv = 0; |
Uint32 pos = cls->findProperty(CIMName(str)); | Uint32 pos = cls->findProperty(CIMName(str)); |
| |
if (pos!=PEG_NOT_FOUND) | if (pos!=PEG_NOT_FOUND) |
|
|
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties | JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties |
(JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) | (JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) |
{ | { |
|
JMPIjvm::cacheIDs (jEnv); |
|
|
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); | CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
| |
for (int i=0,s=cls->getPropertyCount(); i<s; i++) { |
for (int i = 0, s = cls->getPropertyCount (); i < s; i++) |
|
{ |
CIMProperty *cp = new CIMProperty(cls->getProperty(i)); | CIMProperty *cp = new CIMProperty(cls->getProperty(i)); |
jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); | jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); |
| |
jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],jCp); |
jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jCp); |
| |
jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop); |
jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,prop); |
} | } |
| |
return jVec; | return jVec; |
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1setProperties | JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1setProperties |
(JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) | (JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) |
{ | { |
|
JMPIjvm::cacheIDs (jEnv); |
|
|
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); | CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
| |
for (int i=cls->getPropertyCount()-1; i>=0; i--) { |
for (int i = cls->getPropertyCount () - 1; i >= 0; i--) |
|
{ |
cls->removeProperty(i); | cls->removeProperty(i); |
} | } |
for (Uint32 i=0,s=jEnv->CallIntMethod(jVec,instanceMethodIDs[28]); i<s; i++) { |
for (Uint32 i = 0, s = jEnv->CallIntMethod (jVec, JMPIjvm::jv.VectorSize); i < s; i++) |
|
{ |
JMPIjvm::checkException(jEnv); | JMPIjvm::checkException(jEnv); |
| |
jobject o=jEnv->CallObjectMethod(jVec,instanceMethodIDs[16],(i)); |
jobject o = jEnv->CallObjectMethod (jVec,JMPIjvm::jv.VectorElementAt, (i)); |
|
jint jp = jEnv->CallIntMethod (o,JMPIjvm::jv.CIMPropertyCInst); |
jint jp = jEnv->CallIntMethod(o,instanceMethodIDs[29]); |
|
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp); | CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp); |
| |
JMPIjvm::checkException(jEnv); | JMPIjvm::checkException(jEnv); |
|
|
} | } |
} | } |
| |
|
|
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifiers | JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifiers |
(JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) | (JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) |
{ | { |
|
JMPIjvm::cacheIDs (jEnv); |
|
|
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); | CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
| |
for (int i=0,s=cls->getQualifierCount(); i<s; i++) { |
for (int i = 0, s = cls->getQualifierCount (); i < s; i++) |
|
{ |
CIMQualifier *cq = new CIMQualifier(cls->getQualifier(i)); | CIMQualifier *cq = new CIMQualifier(cls->getQualifier(i)); |
jint jCq = DEBUG_ConvertCToJava (CIMQualifier*, jint, cq); | jint jCq = DEBUG_ConvertCToJava (CIMQualifier*, jint, cq); |
jobject qual = jEnv->NewObject(classRefs[26],instanceMethodIDs[37],jCq); |
jobject qual = jEnv->NewObject (JMPIjvm::jv.CIMQualifierClassRef,JMPIjvm::jv.CIMQualifierNewI,jCq); |
| |
jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],qual); |
jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,qual); |
} | } |
| |
return jVec; | return jVec; |
|
|
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getKeys | JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getKeys |
(JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) | (JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) |
{ | { |
|
JMPIjvm::cacheIDs (jEnv); |
|
|
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); | CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
| |
if (cls->hasKeys()) { |
if (cls->hasKeys ()) |
|
{ |
Array<CIMName> keyNames; | Array<CIMName> keyNames; |
cls->getKeyNames(keyNames); | cls->getKeyNames(keyNames); |
for(int i=0, s=keyNames.size();i<s;i++){ |
for (int i = 0, s = keyNames.size ();i < s; i++) |
|
{ |
Uint32 pos=cls->findProperty(keyNames[i]); | Uint32 pos=cls->findProperty(keyNames[i]); |
if (pos!=PEG_NOT_FOUND){ |
if (pos!= PEG_NOT_FOUND) |
|
{ |
CIMProperty *cp = new CIMProperty(cls->getProperty(pos)); | CIMProperty *cp = new CIMProperty(cls->getProperty(pos)); |
jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); | jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); |
| |
jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],jCp); |
jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jCp); |
| |
jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop); |
jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,prop); |
} | } |
} | } |
} | } |
|
|
{ | { |
CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); | CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls); |
const char *str = jEnv->GetStringUTFChars(jN,NULL); | const char *str = jEnv->GetStringUTFChars(jN,NULL); |
jint rv = -1; |
jint rv = 0; |
Uint32 pos = cls->findMethod(String(str)); | Uint32 pos = cls->findMethod(String(str)); |
| |
if (pos!=PEG_NOT_FOUND) { |
if (pos!= PEG_NOT_FOUND) |
|
{ |
rv = DEBUG_ConvertCToJava (CIMMethod*, jint, new CIMMethod(cls->getMethod(pos))); | rv = DEBUG_ConvertCToJava (CIMMethod*, jint, new CIMMethod(cls->getMethod(pos))); |
} | } |
| |
|
|
CIMClass *cf = 0; | CIMClass *cf = 0; |
CIMName clsn = cc->getClassName(); | CIMName clsn = cc->getClassName(); |
| |
if (lo) { |
if (lo) |
|
{ |
cf=new CIMClass(cc->clone()); | cf=new CIMClass(cc->clone()); |
|
|
CIMName clsn=cc->getClassName(); | CIMName clsn=cc->getClassName(); |
|
|
for (int i=cf->getPropertyCount()-1; i>=0; i--) | for (int i=cf->getPropertyCount()-1; i>=0; i--) |
if (cf->getProperty(i).getClassOrigin()==clsn) cf->removeProperty(i); |
{ |
|
if (cf->getProperty (i).getClassOrigin () == clsn) |
|
cf->removeProperty (i); |
|
} |
|
|
return DEBUG_ConvertCToJava (CIMClass*, jint, cf); | return DEBUG_ConvertCToJava (CIMClass*, jint, cf); |
} | } |
else if (jPl) { |
else if (jPl) |
|
{ |
CIMPropertyList pl=getList(jEnv,jPl); | CIMPropertyList pl=getList(jEnv,jPl); |
Array<CIMName> n=pl.getPropertyNameArray(); | Array<CIMName> n=pl.getPropertyNameArray(); |
|
|
cf=new CIMClass(clsn, cc->getSuperClassName()); | cf=new CIMClass(clsn, cc->getSuperClassName()); |
for (int i=0,s=n.size(); i<s; i++) { |
|
|
for (int i = 0, s = n.size (); i < s; i++) |
|
{ |
Uint32 pos=cc->findProperty(n[i]); | Uint32 pos=cc->findProperty(n[i]); |
if (pos!=PEG_NOT_FOUND) { |
|
if (iq) { |
if (pos!= PEG_NOT_FOUND) |
|
{ |
|
if (iq) |
|
{ |
CIMProperty cp=cc->getProperty(pos).clone(); | CIMProperty cp=cc->getProperty(pos).clone(); |
if (!ic) cp.setClassOrigin(CIMName()); |
|
|
if (!ic) |
|
cp.setClassOrigin (CIMName ()); |
|
|
cf->addProperty(cp); | cf->addProperty(cp); |
} | } |
else { |
else |
|
{ |
CIMProperty cp=cc->getProperty(pos); | CIMProperty cp=cc->getProperty(pos); |
CIMName co; | CIMName co; |
if (ic) co=cp.getClassOrigin(); |
|
CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(), |
if (ic) |
cp.getReferenceClassName(),co,cp.getPropagated()); |
co = cp.getClassOrigin (); |
|
|
|
CIMProperty np (cp.getName (), |
|
cp.getValue (), |
|
cp.getArraySize (), |
|
cp.getReferenceClassName (), |
|
co, |
|
cp.getPropagated ()); |
|
|
cf->addProperty(np); | cf->addProperty(np); |
} | } |
} | } |
} | } |
if (iq) for (Uint32 i=0,s=cc->getQualifierCount(); i<s; i++) |
if (iq) |
|
{ |
|
for (Uint32 i = 0, s = cc->getQualifierCount (); i < s; i++) |
|
{ |
cf->addQualifier(cc->getQualifier(i)); | cf->addQualifier(cc->getQualifier(i)); |
} | } |
else if (iq) { |
} |
|
} |
|
else if (iq) |
|
{ |
cf=new CIMClass(cc->clone()); | cf=new CIMClass(cc->clone()); |
if (ic) return DEBUG_ConvertCToJava (CIMClass*, jint, cf); |
|
for (int i=cf->getPropertyCount()-1; i>=0; i--) { |
if (ic) |
|
return DEBUG_ConvertCToJava (CIMClass*, jint, cf); |
|
|
|
for (int i = cf->getPropertyCount () - 1; i >= 0; i--) |
|
{ |
CIMProperty cp=cf->getProperty(i); | CIMProperty cp=cf->getProperty(i); |
|
|
cp.setClassOrigin(CIMName()); | cp.setClassOrigin(CIMName()); |
cf->removeProperty(i); | cf->removeProperty(i); |
cf->addProperty(cp); | cf->addProperty(cp); |
} | } |
} | } |
else { |
else |
|
{ |
cf=new CIMClass(clsn, cc->getSuperClassName()); | cf=new CIMClass(clsn, cc->getSuperClassName()); |
for (int i=cc->getPropertyCount()-1; i>=0; i--) { |
|
|
for (int i = cc->getPropertyCount () - 1; i >= 0; i--) |
|
{ |
CIMProperty cp=cc->getProperty(i); | CIMProperty cp=cc->getProperty(i); |
CIMName co; | CIMName co; |
if (ic) co=cp.getClassOrigin(); |
|
CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(), |
if (ic) |
cp.getReferenceClassName(),co,cp.getPropagated()); |
co = cp.getClassOrigin (); |
|
|
|
CIMProperty np (cp.getName (), |
|
cp.getValue (), |
|
cp.getArraySize (), |
|
cp.getReferenceClassName (), |
|
co, |
|
cp.getPropagated ()); |
|
|
cf->addProperty(np); | cf->addProperty(np); |
} | } |
} | } |
|
|
(JNIEnv *jEnv, jobject jThs, jstring jN) | (JNIEnv *jEnv, jobject jThs, jstring jN) |
{ | { |
const char *str=jEnv->GetStringUTFChars(jN,NULL); | const char *str=jEnv->GetStringUTFChars(jN,NULL); |
|
CIMInstance *ci = new CIMInstance (CIMName (str)); |
|
|
|
jEnv->ReleaseStringUTFChars (jN,str); |
| |
return DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance(CIMName(str))); |
return DEBUG_ConvertCToJava (CIMInstance*, jint, ci); |
} | } |
| |
//Added by Andy Viciu | //Added by Andy Viciu |
|
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); | CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); |
const char *str = jEnv->GetStringUTFChars(jN,NULL); | const char *str = jEnv->GetStringUTFChars(jN,NULL); |
| |
|
jEnv->ReleaseStringUTFChars (jN,str); |
|
|
/* NOT SUPPORTED AND NOT NEEDED*/ | /* NOT SUPPORTED AND NOT NEEDED*/ |
} | } |
| |
|
|
Uint32 pos = ci->findProperty(CIMName(str)); | Uint32 pos = ci->findProperty(CIMName(str)); |
| |
try { | try { |
if (pos!=PEG_NOT_FOUND) { |
if (pos!= PEG_NOT_FOUND) |
|
{ |
CIMProperty cp=ci->getProperty(pos); | CIMProperty cp=ci->getProperty(pos); |
|
|
if (cp.getType()==cv->getType()) | if (cp.getType()==cv->getType()) |
|
{ |
cp.setValue(*cv); | cp.setValue(*cv); |
else { |
} |
|
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 - 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)); | DDD(PEGASUS_STD(cerr)<<"!!! CIMInstance.setProperty : "<<cp.getType()<<" <> "<<cv->getType()<<PEGASUS_STD(endl)); |
| |
throw CIMException(CIM_ERR_FAILED, String("Type mismatch")); | throw CIMException(CIM_ERR_FAILED, String("Type mismatch")); |
} | } |
|
|
ci->removeProperty(pos); | ci->removeProperty(pos); |
ci->addProperty(cp); | ci->addProperty(cp); |
} | } |
else { |
else |
|
{ |
CIMProperty *cp=new CIMProperty(CIMName(str),*cv); | CIMProperty *cp=new CIMProperty(CIMName(str),*cv); |
ci->addProperty(*cp); | ci->addProperty(*cp); |
} | } |
|
|
{ | { |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); | CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); |
const char *str = jEnv->GetStringUTFChars(jN,NULL); | const char *str = jEnv->GetStringUTFChars(jN,NULL); |
jint rv = -1; |
jint rv = 0; |
| |
try { | try { |
Uint32 pos=ci->findProperty(CIMName(str)); | Uint32 pos=ci->findProperty(CIMName(str)); |
if (pos!=PEG_NOT_FOUND) { |
|
|
if (pos != PEG_NOT_FOUND) |
|
{ |
CIMProperty *cp=new CIMProperty(ci->getProperty(pos)); | CIMProperty *cp=new CIMProperty(ci->getProperty(pos)); |
|
|
rv = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); | rv = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); |
} | } |
} | } |
|
|
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getKeyValuePairs | JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getKeyValuePairs |
(JNIEnv *jEnv, jobject jThs, jint jInst, jobject jVec) | (JNIEnv *jEnv, jobject jThs, jint jInst, jobject jVec) |
{ | { |
|
JMPIjvm::cacheIDs (jEnv); |
|
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); | CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); |
| |
for (int i=0,s=ci->getPropertyCount(); i<s; i++) { |
//@HACK |
if (ci->getProperty(i).findQualifier(String("key"))!=PEG_NOT_FOUND) { |
//cout << "ci->getPropertyCount () = " << ci->getPropertyCount () << endl; |
|
for (int i = 0,s = ci->getPropertyCount (); i < s; i++) |
|
{ |
|
//cout << ci->getProperty (i).getName ().getString () |
|
// << " " |
|
// << 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)); | CIMProperty *cp = new CIMProperty(ci->getProperty(i)); |
jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); | jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); |
| |
jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],jCp); |
jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jCp); |
| |
jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop); |
jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,prop); |
} | } |
} | } |
| |
|
|
{ | { |
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); | CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); |
const char *str = jEnv->GetStringUTFChars(jN,NULL); | const char *str = jEnv->GetStringUTFChars(jN,NULL); |
jint rv = -1; |
jint rv = 0; |
Uint32 pos = ci->findQualifier(String(str)); | Uint32 pos = ci->findQualifier(String(str)); |
| |
if (pos!=PEG_NOT_FOUND) { |
if (pos!= PEG_NOT_FOUND) |
|
{ |
rv = DEBUG_ConvertCToJava (CIMQualifier*, jint, new CIMQualifier(ci->getQualifier(pos))); | rv = DEBUG_ConvertCToJava (CIMQualifier*, jint, new CIMQualifier(ci->getQualifier(pos))); |
} | } |
| |
|
|
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperties | JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperties |
(JNIEnv *jEnv, jobject jThs, jint jInst, jobject jVec) | (JNIEnv *jEnv, jobject jThs, jint jInst, jobject jVec) |
{ | { |
|
JMPIjvm::cacheIDs (jEnv); |
|
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); | CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst); |
| |
for (int i=0,s=ci->getPropertyCount(); i<s; i++) { |
for (int i = 0, s = ci->getPropertyCount (); i < s; i++) |
|
{ |
CIMProperty *cp = new CIMProperty(ci->getProperty(i)); | CIMProperty *cp = new CIMProperty(ci->getProperty(i)); |
jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); | jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); |
| |
jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],jCp); |
jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jCp); |
| |
jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop); |
jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,prop); |
} | } |
| |
return jVec; | return jVec; |
|
|
CIMInstance *cf = 0; | CIMInstance *cf = 0; |
CIMName clsn = ci->getClassName(); | CIMName clsn = ci->getClassName(); |
| |
if (lo) { |
if (lo) |
|
{ |
cf=new CIMInstance(ci->clone()); | cf=new CIMInstance(ci->clone()); |
CIMName clsn=ci->getClassName(); | CIMName clsn=ci->getClassName(); |
for (int i=cf->getPropertyCount()-1; i>=0; i--) | for (int i=cf->getPropertyCount()-1; i>=0; i--) |
if (cf->getProperty(i).getClassOrigin()==clsn) cf->removeProperty(i); |
{ |
|
if (cf->getProperty (i).getClassOrigin () == clsn) |
|
cf->removeProperty (i); |
|
} |
return DEBUG_ConvertCToJava (CIMInstance*, jint, cf); | return DEBUG_ConvertCToJava (CIMInstance*, jint, cf); |
} | } |
else if (jPl) { |
else if (jPl) |
|
{ |
CIMPropertyList pl=getList(jEnv,jPl); | CIMPropertyList pl=getList(jEnv,jPl); |
Array<CIMName> n=pl.getPropertyNameArray(); | Array<CIMName> n=pl.getPropertyNameArray(); |
cf=new CIMInstance(clsn); | cf=new CIMInstance(clsn); |
for (int i=0,s=n.size(); i<s; i++) { |
for (int i = 0, s = n.size (); i < s; i++) |
|
{ |
Uint32 pos=ci->findProperty(n[i]); | Uint32 pos=ci->findProperty(n[i]); |
if (pos!=PEG_NOT_FOUND) { |
if (pos!= PEG_NOT_FOUND) |
if (iq) { |
{ |
|
if (iq) |
|
{ |
CIMProperty cp=ci->getProperty(pos).clone(); | CIMProperty cp=ci->getProperty(pos).clone(); |
if (!ic) cp.setClassOrigin(CIMName()); |
if (!ic) |
|
cp.setClassOrigin (CIMName ()); |
cf->addProperty(cp); | cf->addProperty(cp); |
} | } |
else { |
else |
|
{ |
CIMProperty cp=ci->getProperty(pos); | CIMProperty cp=ci->getProperty(pos); |
CIMName co; | CIMName co; |
if (ic) co=cp.getClassOrigin(); |
if (ic) |
|
co = cp.getClassOrigin (); |
CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(), | CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(), |
cp.getReferenceClassName(),co,cp.getPropagated()); | cp.getReferenceClassName(),co,cp.getPropagated()); |
cf->addProperty(np); | cf->addProperty(np); |
|
|
} | } |
cf->setPath(ci->getPath()); | cf->setPath(ci->getPath()); |
} | } |
else if (iq) { |
else if (iq) |
|
{ |
cf=new CIMInstance(ci->clone()); | cf=new CIMInstance(ci->clone()); |
if (ic) return DEBUG_ConvertCToJava (CIMInstance*, jint, cf); |
if (ic) |
for (int i=cf->getPropertyCount()-1; i>=0; i--) { |
return DEBUG_ConvertCToJava (CIMInstance*, jint, cf); |
|
for (int i = cf->getPropertyCount () - 1; i >= 0; i--) |
|
{ |
CIMProperty cp=cf->getProperty(i); | CIMProperty cp=cf->getProperty(i); |
cp.setClassOrigin(CIMName()); | cp.setClassOrigin(CIMName()); |
cf->removeProperty(i); | cf->removeProperty(i); |
cf->addProperty(cp); | cf->addProperty(cp); |
} | } |
} | } |
else { |
else |
|
{ |
cf=new CIMInstance(clsn); | cf=new CIMInstance(clsn); |
for (int i=ci->getPropertyCount()-1; i>=0; i--) { |
for (int i = ci->getPropertyCount () - 1; i >= 0; i--) |
|
{ |
CIMProperty cp=ci->getProperty(i); | CIMProperty cp=ci->getProperty(i); |
CIMName co; | CIMName co; |
if (ic) co=cp.getClassOrigin(); |
if (ic) |
|
co = cp.getClassOrigin (); |
CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(), | CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(), |
cp.getReferenceClassName(),co,cp.getPropagated()); | cp.getReferenceClassName(),co,cp.getPropagated()); |
cf->addProperty(np); | cf->addProperty(np); |
|
|
return DEBUG_ConvertCToJava (CIMInstance*, jint, cf); | return DEBUG_ConvertCToJava (CIMInstance*, jint, cf); |
} | } |
| |
// ------------------------------------- |
/* |
// --- |
* Class: org_pegasus_jmpi_CIMInstance |
// - CIMObjectPath |
* 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 |
|
{ |
|
if (ci) |
|
{ |
|
const CIMObjectPath& cop = ci->getPath (); |
|
|
|
copRet = new CIMObjectPath (cop); |
|
} |
|
} |
|
Catch (jEnv); |
|
|
|
return DEBUG_ConvertCToJava (CIMObjectPath*, jint, copRet); |
|
} |
|
|
|
/* |
|
* Class: org_pegasus_jmpi_CIMInstance |
|
* Method: _setObjectPath |
|
* Signature: (II)V |
|
*/ |
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setObjectPath |
|
(JNIEnv *jEnv, jobject jThs, jint jciCi, jint jciCop) |
|
{ |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciCi); |
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jciCop); |
|
|
|
try |
|
{ |
|
if ( ci |
|
&& cop |
|
) |
|
{ |
|
ci->setPath (*cop); |
|
} |
|
} |
|
Catch (jEnv); |
|
} |
|
|
|
/* |
|
* 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); |
|
Uint32 ui32Ret = 0; |
|
|
|
try |
|
{ |
|
if (ci) |
|
{ |
|
ui32Ret = ci->getPropertyCount (); |
|
} |
|
} |
|
Catch (jEnv); |
|
|
|
return ui32Ret; |
|
} |
|
|
|
/* |
|
* 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 |
|
{ |
|
if (ci) |
|
{ |
|
CIMProperty cp; |
|
|
|
cp = ci->getProperty (ji); |
|
|
|
cpRet = new CIMProperty (cp); |
|
} |
|
} |
|
Catch (jEnv); |
|
|
|
return DEBUG_ConvertCToJava (CIMProperty*, jint, cpRet); |
|
} |
|
|
|
// ------------------------------------- |
|
// --- |
|
// - CIMObjectPath |
|
// --- |
// ------------------------------------- | // ------------------------------------- |
| |
CIMObjectPath* construct() | CIMObjectPath* construct() |
|
|
| |
if (str) | if (str) |
cop->setClassName(str); | cop->setClassName(str); |
|
|
jEnv->ReleaseStringUTFChars(jCn,str); | jEnv->ReleaseStringUTFChars(jCn,str); |
| |
return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); | return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); |
|
|
const char *str2 = NULL; | const char *str2 = NULL; |
| |
try { | try { |
if (jCn) str1=jEnv->GetStringUTFChars(jCn,NULL); |
if (jCn) |
if (jNs) str2=jEnv->GetStringUTFChars(jNs,NULL); |
str1 = jEnv->GetStringUTFChars (jCn,NULL); |
if (str1) cop->setClassName(str1); |
if (jNs) |
if (str2) cop->setNameSpace(str2); |
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); |
if (str1) |
if (str2) jEnv->ReleaseStringUTFChars(jNs,str2); |
jEnv->ReleaseStringUTFChars (jCn,str1); |
|
if (str2) |
|
jEnv->ReleaseStringUTFChars (jNs,str2); |
| |
return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); | return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); |
} | } |
|
|
CIMObjectPath *cop = new CIMObjectPath(ci->getPath()); | CIMObjectPath *cop = new CIMObjectPath(ci->getPath()); |
_nameSpace n; | _nameSpace n; |
| |
if (cop->getNameSpace().isNull()) cop->setNameSpace(n.nameSpace()); |
if (cop->getNameSpace ().isNull ()) |
if (cop->getHost()==NULL) cop->setHost(n.hostName()); |
cop->setNameSpace (n.nameSpace ()); |
|
if (cop->getHost () == NULL) |
|
cop->setHost (n.hostName ()); |
| |
return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); | return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); |
} | } |
|
|
const char *str = jEnv->GetStringUTFChars(jName,NULL); | const char *str = jEnv->GetStringUTFChars(jName,NULL); |
| |
cop->setHost(String(str)); | cop->setHost(String(str)); |
|
|
jEnv->ReleaseStringUTFChars(jName,str); | jEnv->ReleaseStringUTFChars(jName,str); |
} | } |
| |
|
|
const char *str = jEnv->GetStringUTFChars(jName,NULL); | const char *str = jEnv->GetStringUTFChars(jName,NULL); |
| |
cop->setClassName(String(str)); | cop->setClassName(String(str)); |
|
|
jEnv->ReleaseStringUTFChars(jName,str); | jEnv->ReleaseStringUTFChars(jName,str); |
} | } |
| |
|
|
const char *str = jEnv->GetStringUTFChars(jName,NULL); | const char *str = jEnv->GetStringUTFChars(jName,NULL); |
| |
cop->setNameSpace(CIMNamespaceName(str)); | cop->setNameSpace(CIMNamespaceName(str)); |
|
|
jEnv->ReleaseStringUTFChars(jName,str); | jEnv->ReleaseStringUTFChars(jName,str); |
} | } |
| |
|
|
| |
keyBindings.append(CIMKeyBinding(str,*cv)); | keyBindings.append(CIMKeyBinding(str,*cv)); |
cop->setKeyBindings(Array<CIMKeyBinding>(keyBindings)); | cop->setKeyBindings(Array<CIMKeyBinding>(keyBindings)); |
|
|
jEnv->ReleaseStringUTFChars(jId,str); | jEnv->ReleaseStringUTFChars(jId,str); |
} | } |
| |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeys | JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeys |
(JNIEnv *jEnv, jobject jThs, jint jCop, jobject jVec) | (JNIEnv *jEnv, jobject jThs, jint jCop, jobject jVec) |
{ | { |
|
JMPIjvm::cacheIDs (jEnv); |
|
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); | CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
const Array<CIMKeyBinding> &akb = cop->getKeyBindings(); | const Array<CIMKeyBinding> &akb = cop->getKeyBindings(); |
| |
for (Uint32 i=0,s=akb.size(); i<s; i++) { |
for (Uint32 i = 0, s = akb.size (); i < s; i++) |
|
{ |
const String &n=akb[i].getName().getString(); | const String &n=akb[i].getName().getString(); |
const String &v=akb[i].getValue(); | const String &v=akb[i].getValue(); |
CIMKeyBinding::Type t=akb[i].getType(); | CIMKeyBinding::Type t=akb[i].getType(); |
|
|
cp=new CIMProperty(n,*cv, 0, ((CIMObjectPath) akb[i].getValue()).getClassName()); | cp=new CIMProperty(n,*cv, 0, ((CIMObjectPath) akb[i].getValue()).getClassName()); |
| |
jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); | jint jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); |
jobject prop = jEnv->NewObject(classRefs[15],instanceMethodIDs[14],jCp); |
jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jCp); |
| |
jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop); |
jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,prop); |
} | } |
| |
return jVec; | return jVec; |
|
|
const char *strKeyName = jEnv->GetStringUTFChars(jStr,NULL); | const char *strKeyName = jEnv->GetStringUTFChars(jStr,NULL); |
jstring retStr = NULL; | jstring retStr = NULL; |
| |
for (Uint32 i=0,s=akb.size(); i<s; i++) { |
for (Uint32 i = 0,s = akb.size (); i<s; i++) |
|
{ |
const String &n=akb[i].getName().getString(); | const String &n=akb[i].getName().getString(); |
if (n==String(strKeyName)) { |
|
|
if (n == String (strKeyName)) |
|
{ |
retStr=jEnv->NewStringUTF(akb[i].getValue().getCString()); | retStr=jEnv->NewStringUTF(akb[i].getValue().getCString()); |
break; | break; |
} | } |
|
|
CIMObjectPath *cop = new CIMObjectPath(); | CIMObjectPath *cop = new CIMObjectPath(); |
| |
cop->set(String(strCop)); | cop->set(String(strCop)); |
|
|
jEnv->ReleaseStringUTFChars(jStr,strCop); | jEnv->ReleaseStringUTFChars(jStr,strCop); |
| |
return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); | return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop); |
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setKeys | JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setKeys |
(JNIEnv *jEnv, jobject jThs, jint jCop, jobject jVec) | (JNIEnv *jEnv, jobject jThs, jint jCop, jobject jVec) |
{ | { |
|
JMPIjvm::cacheIDs (jEnv); |
|
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); | CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
Array<CIMKeyBinding> akb; | Array<CIMKeyBinding> akb; |
| |
for (Uint32 i=0,s=jEnv->CallIntMethod(jVec,instanceMethodIDs[28]); i<s; i++) { |
for (Uint32 i = 0, s = jEnv->CallIntMethod (jVec,JMPIjvm::jv.VectorSize); i < s; i++) |
jobject o=jEnv->CallObjectMethod(jVec,instanceMethodIDs[16],(i)); |
{ |
|
jobject o = jEnv->CallObjectMethod (jVec,JMPIjvm::jv.VectorElementAt, (i)); |
| |
jint jCp = jEnv->CallIntMethod(o,instanceMethodIDs[29]); |
jint jCp = jEnv->CallIntMethod (o,JMPIjvm::jv.CIMPropertyCInst); |
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jCp); | CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jCp); |
| |
akb.append(CIMKeyBinding(cp->getName(),cp->getValue())); | akb.append(CIMKeyBinding(cp->getName(),cp->getValue())); |
|
|
_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt); | _dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt); |
jstring str = NULL; | jstring str = NULL; |
| |
if (dt->_type & 0x10) { |
if (dt->_type & 0x10) |
char tmp[32]; |
{ |
strcpy(tmp,jTypeToChars[dt->_type-0x10]); |
bool fSuccess = false; |
strcat(tmp,"[]"); |
String tmp = _dataType::convertJavaTypeToChars (dt->_type-0x10, &fSuccess); |
str=jEnv->NewStringUTF(tmp); |
|
|
if (!fSuccess) |
|
return str; |
|
|
|
tmp = tmp + "[]"; |
|
|
|
str = jEnv->NewStringUTF (tmp.getCString ()); |
} | } |
else if (dt->_type & 0x20) { |
else if (dt->_type == 0x20 + 1) // REFERENCE |
|
{ |
String tmp=dt->_refClass+" REF"; | String tmp=dt->_refClass+" REF"; |
|
|
str=jEnv->NewStringUTF(tmp.getCString()); | str=jEnv->NewStringUTF(tmp.getCString()); |
} | } |
else { |
else |
str=jEnv->NewStringUTF(jTypeToChars[dt->_type]); |
{ |
|
bool fSuccess = false; |
|
char *tmp = _dataType::convertJavaTypeToChars (dt->_type, &fSuccess); |
|
|
|
if (!fSuccess) |
|
return str; |
|
|
|
str = jEnv->NewStringUTF (tmp); |
} | } |
| |
return str; | return str; |
} | } |
| |
CIMType toPtype(int jType) { |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDataType__1finalize |
if (jType>13) return (CIMType)14; |
(JNIEnv *jEnv, jobject jThs, jint jDt) |
return (CIMType)(jTypeToPType[jType]); |
{ |
|
_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt); |
|
|
|
delete dt; |
|
|
|
DEBUG_ConvertCleanup (jint, jDt); |
} | } |
| |
| |
|
|
String n(str); | String n(str); |
| |
cp->setParameterName(n); | cp->setParameterName(n); |
|
|
jEnv->ReleaseStringUTFChars(jN,str); | jEnv->ReleaseStringUTFChars(jN,str); |
} | } |
| |
|
|
CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP); | CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP); |
const CIMValue cv = cp->getValue(); | const CIMValue cv = cp->getValue(); |
String ref; | String ref; |
_dataType *type = new _dataType(pTypeToJType[cv.getType()], |
bool fSuccess = false; |
|
int iJType = 0; |
|
_dataType *type = 0; |
|
|
|
iJType = _dataType::convertCTypeToJavaType (cv.getType (), &fSuccess); |
|
|
|
if (fSuccess) |
|
{ |
|
type = new _dataType (iJType, |
cv.getArraySize(), | cv.getArraySize(), |
false, | false, |
false, | false, |
cv.isArray(), | cv.isArray(), |
ref, | ref, |
true); | true); |
|
} |
| |
return DEBUG_ConvertCToJava (_dataType*, jint, type); | return DEBUG_ConvertCToJava (_dataType*, jint, type); |
} | } |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1property | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1property |
(JNIEnv *jEnv, jobject jThs, jstring jN, jint jV) | (JNIEnv *jEnv, jobject jThs, jstring jN, jint jV) |
{ | { |
try { |
|
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); | CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); |
const char *str = jEnv->GetStringUTFChars(jN,NULL); | const char *str = jEnv->GetStringUTFChars(jN,NULL); |
CIMProperty *cp = 0; | CIMProperty *cp = 0; |
|
jint jCp = 0; |
| |
|
try { |
if (cv->getType()!=CIMTYPE_REFERENCE) | if (cv->getType()!=CIMTYPE_REFERENCE) |
|
{ |
cp=new CIMProperty(String(str),*cv); | cp=new CIMProperty(String(str),*cv); |
else { |
} |
if (!cv->isArray()) { |
else |
|
{ |
|
if (!cv->isArray ()) |
|
{ |
CIMObjectPath cop; | CIMObjectPath cop; |
|
|
cv->get(cop); | cv->get(cop); |
cp=new CIMProperty(String(str),*cv,0, cop.getClassName()); | cp=new CIMProperty(String(str),*cv,0, cop.getClassName()); |
} | } |
else { |
else |
|
{ |
throwCIMException(jEnv,"+++ unsupported type in CIMProperty.property"); | throwCIMException(jEnv,"+++ unsupported type in CIMProperty.property"); |
} | } |
} | } |
| |
jEnv->ReleaseStringUTFChars(jN,str); |
jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp); |
|
|
return DEBUG_ConvertCToJava (CIMProperty*, jint, cp); |
|
} | } |
Catch(jEnv); | Catch(jEnv); |
| |
return -1; |
jEnv->ReleaseStringUTFChars (jN,str); |
|
|
|
return jCp; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setValue | JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setValue |
|
|
darr.append(d); | darr.append(d); |
} | } |
break; | break; |
|
case CIMTYPE_CHAR16: { |
|
Char16 c16; |
|
cvin->get (c16); |
|
Array<Char16> c16arr; |
|
cv.get (c16arr); |
|
c16arr.append (c16); |
|
} |
|
break; |
case CIMTYPE_STRING: { | case CIMTYPE_STRING: { |
String str; | String str; |
cvin->get(str); | cvin->get(str); |
|
|
strarr.append(str); | strarr.append(str); |
} | } |
break; | break; |
|
case CIMTYPE_DATETIME: { |
|
CIMDateTime dt; |
|
cvin->get (dt); |
|
Array<CIMDateTime> dtarr; |
|
cv.get (dtarr); |
|
dtarr.append (dt); |
|
} |
|
break; |
case CIMTYPE_REFERENCE: { | case CIMTYPE_REFERENCE: { |
CIMObjectPath ref; | CIMObjectPath ref; |
cvin->get(ref); | cvin->get(ref); |
|
|
const char *str = jEnv->GetStringUTFChars(jN,NULL); | const char *str = jEnv->GetStringUTFChars(jN,NULL); |
| |
cp->setName(CIMName(str)); | cp->setName(CIMName(str)); |
|
|
jEnv->ReleaseStringUTFChars(jN,str); | jEnv->ReleaseStringUTFChars(jN,str); |
} | } |
| |
|
|
{ | { |
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); | CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
String ref = cp->getReferenceClassName().getString(); | String ref = cp->getReferenceClassName().getString(); |
_dataType *type = new _dataType(pTypeToJType[cp->getType()], |
bool fSuccess = false; |
|
int iJType = 0; |
|
_dataType *type = 0; |
|
|
|
iJType = _dataType::convertCTypeToJavaType (cp->getType (), &fSuccess); |
|
|
|
if (fSuccess) |
|
{ |
|
type = new _dataType (iJType, |
cp->getArraySize(), | cp->getArraySize(), |
ref.size() ? true : false, | ref.size() ? true : false, |
false, | false, |
cp->isArray(), | cp->isArray(), |
ref, | ref, |
true); | true); |
|
} |
| |
return DEBUG_ConvertCToJava (_dataType*, jint, type); | return DEBUG_ConvertCToJava (_dataType*, jint, type); |
} | } |
|
|
(JNIEnv *jEnv, jobject jThs, jint jP, jint jDt) | (JNIEnv *jEnv, jobject jThs, jint jP, jint jDt) |
{ | { |
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); | CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
_dataType *dt = (_dataType*)jDt; |
_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt); |
CIMValue val; | CIMValue val; |
|
bool fSuccess = false; |
|
CIMType cType = CIMTYPE_BOOLEAN; |
|
|
|
cType = _dataType::convertJavaTypeToCType (dt->_type, &fSuccess); |
| |
val.setNullValue(toPtype(dt->_type),dt->_array); |
if (fSuccess) |
|
{ |
|
val.setNullValue (cType, dt->_array); |
| |
CIMProperty *np = new CIMProperty(cp->getName(),val); | CIMProperty *np = new CIMProperty(cp->getName(),val); |
| |
delete cp; | delete cp; |
| |
|
DEBUG_ConvertCleanup (jint, jP); |
|
|
return DEBUG_ConvertCToJava (CIMProperty*, jint, np); | return DEBUG_ConvertCToJava (CIMProperty*, jint, np); |
} | } |
|
else |
|
{ |
|
return DEBUG_ConvertCToJava (CIMProperty*, jint, cp); |
|
} |
|
} |
| |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMProperty__1getIdentifier | JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMProperty__1getIdentifier |
(JNIEnv *jEnv, jobject jThs, jint jP) | (JNIEnv *jEnv, jobject jThs, jint jP) |
|
|
DEBUG_ConvertCleanup (jint, jP); | DEBUG_ConvertCleanup (jint, jP); |
} | } |
| |
|
/* |
|
* Class: org_pegasus_jmpi_CIMProperty |
|
* Method: _findQualifier |
|
* Signature: (Ljava/lang/String;)I |
|
*/ |
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1findQualifier |
|
(JNIEnv *jEnv, jobject jThs, jint jP, jstring jQualifier) |
|
{ |
|
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
|
const char *str = jEnv->GetStringUTFChars (jQualifier, NULL); |
|
int index = PEG_NOT_FOUND; |
|
|
|
try |
|
{ |
|
index = cp->findQualifier (CIMName (str)); |
|
|
|
jEnv->ReleaseStringUTFChars (jQualifier, str); |
|
} |
|
Catch (jEnv); |
|
|
|
return index; |
|
} |
|
|
|
/* |
|
* Class: org_pegasus_jmpi_CIMProperty |
|
* Method: _getQualifier |
|
* Signature: (I)I |
|
*/ |
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getQualifier |
|
(JNIEnv *jEnv, jobject jThs, jint jP, jint jIndex) |
|
{ |
|
CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP); |
|
CIMQualifier *cq = NULL; |
|
CIMQualifier qualifier; |
|
|
|
try |
|
{ |
|
qualifier = cp->getQualifier ((Uint32)jIndex); |
|
cq = new CIMQualifier (qualifier); |
|
} |
|
Catch (jEnv); |
|
|
|
return DEBUG_ConvertCToJava (CIMQualifier *, jint, cq); |
|
} |
|
|
|
|
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
// - CIMQualifierType | // - CIMQualifierType |
|
|
(JNIEnv *jEnv, jobject jThs, jint jQ, jstring jN) | (JNIEnv *jEnv, jobject jThs, jint jQ, jstring jN) |
{ | { |
CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ); | CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ); |
CIMQualifierDecl *nqt; |
|
const char *str = jEnv->GetStringUTFChars(jN,NULL); | const char *str = jEnv->GetStringUTFChars(jN,NULL); |
|
jint jret = 0; |
| |
nqt=qt; |
|
if (qt->isUninitialized()) | if (qt->isUninitialized()) |
nqt=new CIMQualifierDecl(CIMName(str),CIMValue(),CIMScope()); |
{ |
|
CIMQualifierDecl *nqt = new CIMQualifierDecl (CIMName (str),CIMValue (),CIMScope ()); |
|
|
|
jret = DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, nqt); |
|
} |
else | else |
|
{ |
qt->setName(CIMName(str)); | qt->setName(CIMName(str)); |
|
|
|
CIMQualifierDecl *nqt = new CIMQualifierDecl (*qt); |
|
|
|
jret = DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, nqt); |
|
} |
|
|
jEnv->ReleaseStringUTFChars(jN,str); | jEnv->ReleaseStringUTFChars(jN,str); |
| |
return DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, nqt); |
return jret; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setValue | JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setValue |
|
|
dt=new CIMDateTime(); | dt=new CIMDateTime(); |
else | else |
dt=new CIMDateTime(String(str)); | dt=new CIMDateTime(String(str)); |
|
|
jEnv->ReleaseStringUTFChars(jN,str); | jEnv->ReleaseStringUTFChars(jN,str); |
| |
return DEBUG_ConvertCToJava (CIMDateTime*, jint, dt); | return DEBUG_ConvertCToJava (CIMDateTime*, jint, dt); |
|
|
{ | { |
CIMMethod *cm = DEBUG_ConvertJavaToC (jint, CIMMethod*, jM); | CIMMethod *cm = DEBUG_ConvertJavaToC (jint, CIMMethod*, jM); |
| |
return DEBUG_ConvertCToJava (CIMType, jint, cm->getType()); |
return DEBUG_ConvertCToJava (CIMType *, jint, new CIMType (cm->getType ())); |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize | JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize |
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); | return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue_makeInt |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1makeInt |
(JNIEnv *jEnv, jobject jThs, jlong ji, jboolean notSigned) | (JNIEnv *jEnv, jobject jThs, jlong ji, jboolean notSigned) |
{ | { |
CIMValue *cv = NULL; | CIMValue *cv = NULL; |
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); | return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1ref |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1cop |
(JNIEnv *jEnv, jobject jThs, jint jR) | (JNIEnv *jEnv, jobject jThs, jint jR) |
{ | { |
CIMObjectPath *ref = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jR); | CIMObjectPath *ref = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jR); |
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); | return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
} | } |
| |
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1char16 |
|
(JNIEnv *jEnv, jobject jThs, jchar jChar16) |
|
{ |
|
Char16 c16 (jChar16); |
|
CIMValue *cv = new CIMValue (c16); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1object |
|
(JNIEnv *jEnv, jobject jThs, jint jO) |
|
{ |
|
CIMObject *co = DEBUG_ConvertJavaToC (jint, CIMObject*, jO); |
|
CIMValue *cv = new CIMValue (*co); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
|
} |
|
|
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMValue__1isArray | JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMValue__1isArray |
(JNIEnv *jEnv, jobject jThs, jint jP) | (JNIEnv *jEnv, jobject jThs, jint jP) |
{ | { |
|
|
jsize len = jEnv->GetArrayLength(jshortA); | jsize len = jEnv->GetArrayLength(jshortA); |
jshort *jsA = jEnv->GetShortArrayElements(jshortA,&b); | jshort *jsA = jEnv->GetShortArrayElements(jshortA,&b); |
| |
if (notSigned) { |
if (notSigned) |
|
{ |
Array<Uint8> u8; | Array<Uint8> u8; |
for (jsize i=0;i<len;i++) | for (jsize i=0;i<len;i++) |
u8.append((Uint8)jsA[i]); | u8.append((Uint8)jsA[i]); |
cv=new CIMValue(u8); | cv=new CIMValue(u8); |
} | } |
else { |
else |
|
{ |
Array<Sint8> s8; | Array<Sint8> s8; |
for (jsize i=0;i<len;i++) | for (jsize i=0;i<len;i++) |
s8.append((Sint8)jsA[i]); | s8.append((Sint8)jsA[i]); |
cv=new CIMValue(s8); | cv=new CIMValue(s8); |
} | } |
| |
|
jEnv->ReleaseShortArrayElements (jshortA, jsA, len); |
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); | return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
} | } |
| |
|
|
jsize len = jEnv->GetArrayLength(jintA); | jsize len = jEnv->GetArrayLength(jintA); |
jint *jiA = jEnv->GetIntArrayElements(jintA,&b); | jint *jiA = jEnv->GetIntArrayElements(jintA,&b); |
| |
if (notSigned) { |
if (notSigned) |
|
{ |
Array<Uint16> u16; | Array<Uint16> u16; |
for (jsize i=0;i<len;i++) | for (jsize i=0;i<len;i++) |
u16.append((Uint16)jiA[i]); | u16.append((Uint16)jiA[i]); |
cv=new CIMValue(u16); | cv=new CIMValue(u16); |
} | } |
else { |
else |
|
{ |
Array<Sint16> s16; | Array<Sint16> s16; |
for (jsize i=0;i<len;i++) | for (jsize i=0;i<len;i++) |
s16.append((Sint16)jiA[i]); | s16.append((Sint16)jiA[i]); |
cv=new CIMValue(s16); | cv=new CIMValue(s16); |
} | } |
| |
|
jEnv->ReleaseIntArrayElements (jintA, jiA, len); |
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); | return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
} | } |
| |
|
|
jsize len = jEnv->GetArrayLength(jlongA); | jsize len = jEnv->GetArrayLength(jlongA); |
jlong *jlA = jEnv->GetLongArrayElements(jlongA,&b); | jlong *jlA = jEnv->GetLongArrayElements(jlongA,&b); |
| |
if (notSigned) { |
if (notSigned) |
|
{ |
Array<Uint32> u32; | Array<Uint32> u32; |
for (jsize i=0;i<len;i++) | for (jsize i=0;i<len;i++) |
u32.append((Uint32)jlA[i]); | u32.append((Uint32)jlA[i]); |
cv=new CIMValue(u32); | cv=new CIMValue(u32); |
} | } |
else { |
else |
|
{ |
Array<Sint32> s32; | Array<Sint32> s32; |
for (jsize i=0;i<len;i++) | for (jsize i=0;i<len;i++) |
s32.append((Sint32)jlA[i]); | s32.append((Sint32)jlA[i]); |
cv=new CIMValue(s32); | cv=new CIMValue(s32); |
} | } |
| |
|
jEnv->ReleaseLongArrayElements (jlongA, jlA, len); |
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); | return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
} | } |
| |
|
|
jsize len = jEnv->GetArrayLength(jlongA); | jsize len = jEnv->GetArrayLength(jlongA); |
jlong *jlA = jEnv->GetLongArrayElements(jlongA,&b); | jlong *jlA = jEnv->GetLongArrayElements(jlongA,&b); |
| |
if (notSigned) { |
if (notSigned) |
|
{ |
Array<Uint64> u64; | Array<Uint64> u64; |
for (jsize i=0;i<len;i++) | for (jsize i=0;i<len;i++) |
u64.append((Uint64)jlA[i]); | u64.append((Uint64)jlA[i]); |
cv=new CIMValue(u64); | cv=new CIMValue(u64); |
} | } |
else { |
else |
|
{ |
Array<Sint64> s64; | Array<Sint64> s64; |
for (jsize i=0;i<len;i++) | for (jsize i=0;i<len;i++) |
s64.append((Sint64)jlA[i]); | s64.append((Sint64)jlA[i]); |
cv=new CIMValue(s64); | cv=new CIMValue(s64); |
} | } |
| |
|
jEnv->ReleaseLongArrayElements (jlongA, jlA, len); |
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); | return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
} | } |
| |
|
|
(JNIEnv *jEnv, jobject jThs, jobjectArray jstringA) | (JNIEnv *jEnv, jobject jThs, jobjectArray jstringA) |
{ | { |
CIMValue *cv = NULL; | CIMValue *cv = NULL; |
jboolean b; |
|
jsize len = jEnv->GetArrayLength(jstringA); | jsize len = jEnv->GetArrayLength(jstringA); |
Array<String> strA; | Array<String> strA; |
| |
for (jsize i=0;i<len;i++) { |
for (jsize i = 0;i < len; i++) |
|
{ |
jstring jsA=(jstring)jEnv->GetObjectArrayElement(jstringA,i); | jstring jsA=(jstring)jEnv->GetObjectArrayElement(jstringA,i); |
const char *str=jEnv->GetStringUTFChars(jsA,NULL); | const char *str=jEnv->GetStringUTFChars(jsA,NULL); |
|
|
strA.append(String(str)); | strA.append(String(str)); |
|
|
jEnv->ReleaseStringUTFChars(jsA,str); | jEnv->ReleaseStringUTFChars(jsA,str); |
} | } |
| |
|
|
bA.append((Boolean)jbA[i]); | bA.append((Boolean)jbA[i]); |
cv=new CIMValue(bA); | cv=new CIMValue(bA); |
| |
|
jEnv->ReleaseBooleanArrayElements (jboolA, jbA, len); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1floatArray |
|
(JNIEnv *jEnv, jobject jThs, jfloatArray jfloatA) |
|
{ |
|
CIMValue *cv = NULL; |
|
jboolean b; |
|
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); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1doubleArray |
|
(JNIEnv *jEnv, jobject jThs, jdoubleArray jdoubleA) |
|
{ |
|
CIMValue *cv = NULL; |
|
jboolean b; |
|
jsize len = jEnv->GetArrayLength (jdoubleA); |
|
jdouble *jdA = jEnv->GetDoubleArrayElements (jdoubleA,&b); |
|
Array<double> dA; |
|
|
|
for (jsize i = 0; i < len; i++) |
|
dA.append ((double)jdA[i]); |
|
cv = new CIMValue (dA); |
|
|
|
jEnv->ReleaseDoubleArrayElements (jdoubleA, jdA, len); |
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); | return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1refArray |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1copArray |
(JNIEnv *jEnv, jobject jThs, jintArray jintA) | (JNIEnv *jEnv, jobject jThs, jintArray jintA) |
{ | { |
CIMValue *cv = NULL; | CIMValue *cv = NULL; |
|
|
cA.append(*((CIMObjectPath*)jiA[i])); | cA.append(*((CIMObjectPath*)jiA[i])); |
cv=new CIMValue(cA); | cv=new CIMValue(cA); |
| |
|
jEnv->ReleaseIntArrayElements (jintA, jiA, len); |
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); | return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1datetimeArray |
(JNIEnv *jEnv, jobject jThs, jint jP) |
(JNIEnv *jEnv, jobject jThs, jintArray jintA) |
{ | { |
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jP); |
CIMValue *cv = NULL; |
|
jboolean b; |
|
jsize len = jEnv->GetArrayLength (jintA); |
|
jint *jiA = jEnv->GetIntArrayElements (jintA,&b); |
|
Array<CIMDateTime> cA; |
| |
return DEBUG_ConvertCToJava (int, jint, pTypeToJType[cv->getType()]); |
for (jsize i = 0; i < len; i++) |
} |
cA.append (*((CIMDateTime*)jiA[i])); |
|
cv = new CIMValue (cA); |
| |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString |
jEnv->ReleaseIntArrayElements (jintA, jiA, len); |
(JNIEnv *jEnv, jobject jThs, jint jV) |
|
{ |
|
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); |
|
| |
return (jstring)jEnv->NewStringUTF(cv->toString().getCString()); |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
} | } |
| |
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMValue__1getValue |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1objectArray |
(JNIEnv *jEnv, jobject jThs, jint jV) |
(JNIEnv *jEnv, jobject jThs, jintArray jintA) |
{ | { |
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); |
CIMValue *cv = NULL; |
|
jboolean b; |
|
jsize len = jEnv->GetArrayLength (jintA); |
|
jint *jiA = jEnv->GetIntArrayElements (jintA,&b); |
|
Array<CIMObject> cA; |
| |
if (cv->isNull()) |
for (jsize i = 0; i < len; i++) |
return NULL; |
cA.append (*((CIMObject*)jiA[i])); |
|
cv = new CIMValue (cA); |
| |
CIMType type=cv->getType(); |
jEnv->ReleaseIntArrayElements (jintA, jiA, len); |
| |
if (!cv->isArray()) { |
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
switch (type) { |
} |
case CIMTYPE_BOOLEAN: |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1char16Array |
|
(JNIEnv *jEnv, jobject jThs, jcharArray jcharA) |
|
{ |
|
CIMValue *cv = NULL; |
|
jboolean b; |
|
jsize len = jEnv->GetArrayLength (jcharA); |
|
jchar *jcA = jEnv->GetCharArrayElements (jcharA,&b); |
|
Array<Char16> cA; |
|
|
|
for (jsize i = 0; i < len; i++) |
|
cA.append (Char16 (jcA[i])); |
|
cv = new CIMValue (cA); |
|
|
|
jEnv->ReleaseCharArrayElements (jcharA, jcA, len); |
|
|
|
return DEBUG_ConvertCToJava (CIMValue*, jint, cv); |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType |
|
(JNIEnv *jEnv, jobject jThs, jint jP) |
|
{ |
|
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jP); |
|
bool fSuccess = false; |
|
int iJType = 0; |
|
|
|
iJType = _dataType::convertCTypeToJavaType (cv->getType (), &fSuccess); |
|
|
|
return DEBUG_ConvertCToJava (int, jint, iJType); |
|
} |
|
|
|
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString |
|
(JNIEnv *jEnv, jobject jThs, jint jV) |
|
{ |
|
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); |
|
|
|
return (jstring)jEnv->NewStringUTF (cv->toString ().getCString ()); |
|
} |
|
|
|
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMValue__1getValue |
|
(JNIEnv *jEnv, jobject jThs, jint jV) |
|
{ |
|
JMPIjvm::cacheIDs (jEnv); |
|
|
|
CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV); |
|
|
|
if (cv->isNull ()) |
|
return NULL; |
|
|
|
CIMType type = cv->getType (); |
|
|
|
if (!cv->isArray ()) |
|
{ |
|
switch (type) |
|
{ |
|
case CIMTYPE_BOOLEAN: |
Boolean bo; | Boolean bo; |
cv->get(bo); | cv->get(bo); |
return jEnv->NewObject(classRefs[1],instanceMethodIDs[1],bo); |
return jEnv->NewObject (JMPIjvm::jv.BooleanClassRef, |
break; |
JMPIjvm::jv.BooleanNewZ, |
|
bo); |
case CIMTYPE_SINT8: | case CIMTYPE_SINT8: |
Sint8 s8; | Sint8 s8; |
cv->get(s8); | cv->get(s8); |
return jEnv->NewObject(classRefs[2],instanceMethodIDs[2],s8); |
return jEnv->NewObject (JMPIjvm::jv.ByteClassRef, |
break; |
JMPIjvm::jv.ByteNewB, |
|
s8); |
case CIMTYPE_UINT8: | case CIMTYPE_UINT8: |
Uint8 u8; | Uint8 u8; |
cv->get(u8); | cv->get(u8); |
return jEnv->NewObject(classRefs[8],instanceMethodIDs[8],u8); |
return jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef, |
break; |
JMPIjvm::jv.UnsignedInt8NewS, |
|
u8); |
case CIMTYPE_SINT16: | case CIMTYPE_SINT16: |
Sint16 s16; | Sint16 s16; |
cv->get(s16); | cv->get(s16); |
return jEnv->NewObject(classRefs[3],instanceMethodIDs[3],s16); |
return jEnv->NewObject (JMPIjvm::jv.ShortClassRef, |
break; |
JMPIjvm::jv.ShortNewS, |
|
s16); |
case CIMTYPE_UINT16: | case CIMTYPE_UINT16: |
Uint16 u16; | Uint16 u16; |
cv->get(u16); | cv->get(u16); |
return jEnv->NewObject(classRefs[9],instanceMethodIDs[9],u16); |
return jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef, |
break; |
JMPIjvm::jv.UnsignedInt16NewI, |
|
u16); |
case CIMTYPE_SINT32: | case CIMTYPE_SINT32: |
Sint32 s32; | Sint32 s32; |
cv->get(s32); | cv->get(s32); |
return jEnv->NewObject(classRefs[4],instanceMethodIDs[4],s32); |
return jEnv->NewObject (JMPIjvm::jv.IntegerClassRef, |
break; |
JMPIjvm::jv.IntegerNewI, |
|
s32); |
case CIMTYPE_UINT32: | case CIMTYPE_UINT32: |
Uint32 u32; | Uint32 u32; |
cv->get(u32); | cv->get(u32); |
return jEnv->NewObject(classRefs[10],instanceMethodIDs[10],u32); |
return jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef, |
break; |
JMPIjvm::jv.UnsignedInt32NewJ, |
|
u32); |
case CIMTYPE_SINT64: | case CIMTYPE_SINT64: |
Sint64 s64; | Sint64 s64; |
cv->get(s64); | cv->get(s64); |
return jEnv->NewObject(classRefs[5],instanceMethodIDs[5],s64); |
return jEnv->NewObject (JMPIjvm::jv.LongClassRef, |
break; |
JMPIjvm::jv.LongNewJ, |
case CIMTYPE_UINT64: { |
s64); |
|
case CIMTYPE_UINT64: |
|
{ |
Uint64 u64; | Uint64 u64; |
cv->get(u64); | cv->get(u64); |
jobject big=jEnv->CallStaticObjectMethod(classRefs[14],staticMethodIDs[0],u64); |
jobject jBIG = jEnv->CallStaticObjectMethod (JMPIjvm::jv.BigIntegerClassRef, |
return jEnv->NewObject(classRefs[11],instanceMethodIDs[11],big); |
JMPIjvm::jv.BigIntegerValueOf, |
|
u64); |
|
return jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef, |
|
JMPIjvm::jv.UnsignedInt64NewBi, |
|
jBIG); |
} | } |
break; |
|
case CIMTYPE_REAL32: | case CIMTYPE_REAL32: |
float f; | float f; |
cv->get(f); | cv->get(f); |
return jEnv->NewObject(classRefs[6],instanceMethodIDs[6],f); |
return jEnv->NewObject (JMPIjvm::jv.FloatClassRef, |
break; |
JMPIjvm::jv.FloatNewF, |
|
f); |
case CIMTYPE_REAL64: | case CIMTYPE_REAL64: |
double d; | double d; |
cv->get(d); | cv->get(d); |
return jEnv->NewObject(classRefs[7],instanceMethodIDs[7],d); |
return jEnv->NewObject (JMPIjvm::jv.DoubleClassRef, |
break; |
JMPIjvm::jv.DoubleNewD, |
case CIMTYPE_STRING: { |
d); |
|
case CIMTYPE_STRING: |
|
{ |
String s; | String s; |
jstring str; |
|
cv->get(s); | cv->get(s); |
str=jEnv->NewStringUTF(s.getCString()); |
return jEnv->NewStringUTF (s.getCString ()); |
return str; |
|
} | } |
break; |
case CIMTYPE_REFERENCE: |
case CIMTYPE_REFERENCE: { |
{ |
CIMObjectPath ref; | CIMObjectPath ref; |
cv->get(ref); | cv->get(ref); |
jint jOp = DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(ref)); | jint jOp = DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(ref)); |
return jEnv->NewObject(classRefs[12],instanceMethodIDs[12],jOp); |
return jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef, |
|
JMPIjvm::jv.CIMObjectPathNewI, |
|
jOp); |
} | } |
break; |
|
case CIMTYPE_CHAR16: | case CIMTYPE_CHAR16: |
throwCIMException(jEnv,"+++ Char16 not yet supported"); |
{ |
break; |
Char16 c16; |
case CIMTYPE_DATETIME: { |
cv->get (c16); |
|
return jEnv->NewObject (JMPIjvm::jv.CharacterClassRef, |
|
JMPIjvm::jv.CharacterNewC, |
|
(jchar)c16); |
|
} |
|
case CIMTYPE_DATETIME: |
|
{ |
CIMDateTime dt; | CIMDateTime dt; |
cv->get(dt); | cv->get(dt); |
jint jDT = DEBUG_ConvertCToJava (CIMDateTime*, jint, new CIMDateTime(dt)); | jint jDT = DEBUG_ConvertCToJava (CIMDateTime*, jint, new CIMDateTime(dt)); |
return jEnv->NewObject(classRefs[24],instanceMethodIDs[35],jDT); |
return jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef, |
|
JMPIjvm::jv.CIMDateTimeNewI, |
|
jDT); |
} | } |
break; |
|
case CIMTYPE_OBJECT: | case CIMTYPE_OBJECT: |
throwCIMException(jEnv,"+++ Object not yet supported"); |
{ |
break; |
CIMObject co; |
|
cv->get (co); |
|
if (co.isClass ()) |
|
{ |
|
jint jCC = DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass (co)); |
|
|
|
return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef, |
|
JMPIjvm::jv.CIMObjectNewIZ, |
|
jCC, |
|
(jboolean)true); |
|
} |
|
else |
|
{ |
|
jint jCI = DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance (co)); |
|
|
|
return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef, |
|
JMPIjvm::jv.CIMObjectNewIZ, |
|
jCI, |
|
(jboolean)false); |
|
} |
|
} |
default: | default: |
throwCIMException(jEnv,"+++ unsupported type: "); | throwCIMException(jEnv,"+++ unsupported type: "); |
} | } |
} | } |
else { |
else |
switch (type) { |
{ |
case CIMTYPE_BOOLEAN: { |
switch (type) |
|
{ |
|
case CIMTYPE_BOOLEAN: |
|
{ |
Array<Boolean> bo; | Array<Boolean> bo; |
|
|
cv->get(bo); | cv->get(bo); |
|
|
int s=bo.size(); | int s=bo.size(); |
jobjectArray jbooleanA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[1],0); |
jobjectArray jbooleanA = (jobjectArray)jEnv->NewObjectArray (s, |
for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jbooleanA, i, |
JMPIjvm::jv.BooleanClassRef, |
jEnv->NewObject(classRefs[1],instanceMethodIDs[1],bo[i])); |
0); |
|
|
|
for (int i = 0; i < s; i++) |
|
jEnv->SetObjectArrayElement (jbooleanA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.BooleanClassRef, |
|
JMPIjvm::jv.BooleanNewZ, |
|
bo[i])); |
return jbooleanA; | return jbooleanA; |
} | } |
break; |
case CIMTYPE_SINT8: |
case CIMTYPE_SINT8: { |
{ |
Array<Sint8> s8; | Array<Sint8> s8; |
|
|
cv->get(s8); | cv->get(s8); |
|
|
int s=s8.size(); | int s=s8.size(); |
jobjectArray jbyteA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[2],0); |
jobjectArray jbyteA = (jobjectArray)jEnv->NewObjectArray (s, |
for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jbyteA, i, |
JMPIjvm::jv.ByteClassRef, |
jEnv->NewObject(classRefs[2],instanceMethodIDs[2],s8[i])); |
0); |
|
|
|
for (int i = 0; i < s; i++) |
|
jEnv->SetObjectArrayElement (jbyteA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.ByteClassRef, |
|
JMPIjvm::jv.ByteNewB, |
|
s8[i])); |
return jbyteA; | return jbyteA; |
} | } |
break; |
case CIMTYPE_UINT8: |
case CIMTYPE_UINT8: { |
{ |
Array<Uint8> u8; | Array<Uint8> u8; |
|
|
cv->get(u8); | cv->get(u8); |
|
|
int s=u8.size(); | int s=u8.size(); |
jobjectArray jshortA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[8],0); |
jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray (s, |
for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jshortA, i, |
JMPIjvm::jv.UnsignedInt8ClassRef, |
jEnv->NewObject(classRefs[8],instanceMethodIDs[8],u8[i])); |
0); |
|
for (int i = 0; i < s; i++) |
|
jEnv->SetObjectArrayElement (jshortA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef, |
|
JMPIjvm::jv.UnsignedInt8NewS, |
|
u8[i])); |
return jshortA; | return jshortA; |
} | } |
break; |
case CIMTYPE_SINT16: |
case CIMTYPE_SINT16: { |
{ |
Array<Sint16> s16; | Array<Sint16> s16; |
|
|
cv->get(s16); | cv->get(s16); |
|
|
int s=s16.size(); | int s=s16.size(); |
jobjectArray jshortA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[3],0); |
jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray (s, |
for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jshortA, i, |
JMPIjvm::jv.ShortClassRef, |
jEnv->NewObject(classRefs[3],instanceMethodIDs[3],s16[i])); |
0); |
|
|
|
for (int i = 0; i < s; i++) |
|
jEnv->SetObjectArrayElement (jshortA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.ShortClassRef, |
|
JMPIjvm::jv.ShortNewS, |
|
s16[i])); |
return jshortA; | return jshortA; |
} | } |
break; |
case CIMTYPE_UINT16: |
case CIMTYPE_UINT16: { |
{ |
Array<Uint16> u16; | Array<Uint16> u16; |
|
|
cv->get(u16); | cv->get(u16); |
|
|
int s=u16.size(); | int s=u16.size(); |
jobjectArray jintA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[9],0); |
jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray (s, |
for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jintA, i, |
JMPIjvm::jv.UnsignedInt16ClassRef, |
jEnv->NewObject(classRefs[9],instanceMethodIDs[9],u16[i])); |
0); |
|
|
|
for (int i = 0; i < s; i++) |
|
jEnv->SetObjectArrayElement (jintA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef, |
|
JMPIjvm::jv.UnsignedInt16NewI, |
|
u16[i])); |
return jintA; | return jintA; |
} | } |
break; |
case CIMTYPE_SINT32: |
case CIMTYPE_SINT32: { |
{ |
Array<Sint32> s32; | Array<Sint32> s32; |
|
|
cv->get(s32); | cv->get(s32); |
|
|
int s=s32.size(); | int s=s32.size(); |
jobjectArray jintA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[4],0); |
jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray (s, |
for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jintA, i, |
JMPIjvm::jv.IntegerClassRef, |
jEnv->NewObject(classRefs[4],instanceMethodIDs[4],s32[i])); |
0); |
|
|
|
for (int i = 0; i < s; i++) |
|
jEnv->SetObjectArrayElement (jintA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.IntegerClassRef, |
|
JMPIjvm::jv.IntegerNewI, |
|
s32[i])); |
return jintA; | return jintA; |
} | } |
break; |
case CIMTYPE_UINT32: |
case CIMTYPE_UINT32: { |
{ |
Array<Uint32> u32; | Array<Uint32> u32; |
|
|
cv->get(u32); | cv->get(u32); |
|
|
int s=u32.size(); | int s=u32.size(); |
jobjectArray jlongA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[10],0); |
jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray (s, |
for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jlongA, i, |
JMPIjvm::jv.UnsignedInt32ClassRef, |
jEnv->NewObject(classRefs[10],instanceMethodIDs[10],u32[i])); |
0); |
|
|
|
for (int i = 0; i < s; i++) |
|
jEnv->SetObjectArrayElement (jlongA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef, |
|
JMPIjvm::jv.UnsignedInt32NewJ, |
|
u32[i])); |
return jlongA; | return jlongA; |
} | } |
break; |
case CIMTYPE_SINT64: |
case CIMTYPE_SINT64: { |
{ |
Array<Sint64> s64; | Array<Sint64> s64; |
|
|
cv->get(s64); | cv->get(s64); |
|
|
int s=s64.size(); | int s=s64.size(); |
jobjectArray jlongA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[5],0); |
jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray (s, |
for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jlongA, i, |
JMPIjvm::jv.LongClassRef, |
jEnv->NewObject(classRefs[5],instanceMethodIDs[5],s64[i])); |
0); |
|
|
|
for (int i = 0; i < s; i++) |
|
jEnv->SetObjectArrayElement (jlongA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.LongClassRef, |
|
JMPIjvm::jv.LongNewJ, |
|
s64[i])); |
return jlongA; | return jlongA; |
} | } |
break; |
|
case CIMTYPE_UINT64: | case CIMTYPE_UINT64: |
throwCIMException(jEnv,"+++ UnisgnetInt64 not yet supported"); |
{ |
break; |
Array<Uint64> u64; |
case CIMTYPE_REAL32: { |
|
|
cv->get (u64); |
|
|
|
int s = u64.size (); |
|
jobjectArray ju64A = (jobjectArray)jEnv->NewObjectArray (s, |
|
JMPIjvm::jv.UnsignedInt64ClassRef, |
|
0); |
|
|
|
for (int i = 0; i < s; i++) |
|
{ |
|
jobject jBIG = jEnv->CallStaticObjectMethod (JMPIjvm::jv.BigIntegerClassRef, |
|
JMPIjvm::jv.BigIntegerValueOf, |
|
u64[i]); |
|
|
|
jEnv->SetObjectArrayElement (ju64A, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef, |
|
JMPIjvm::jv.UnsignedInt64NewBi, |
|
jBIG)); |
|
} |
|
return ju64A; |
|
} |
|
case CIMTYPE_REAL32: |
|
{ |
Array<Real32> r32; | Array<Real32> r32; |
|
|
cv->get(r32); | cv->get(r32); |
|
|
int s=r32.size(); | int s=r32.size(); |
jobjectArray jfloatA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[6],0); |
jobjectArray jfloatA = (jobjectArray)jEnv->NewObjectArray (s, |
for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jfloatA, i, |
JMPIjvm::jv.FloatClassRef, |
jEnv->NewObject(classRefs[6],instanceMethodIDs[6],r32[i])); |
0); |
|
|
|
for (int i = 0; i < s; i++) |
|
jEnv->SetObjectArrayElement (jfloatA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.FloatClassRef, |
|
JMPIjvm::jv.FloatNewF, |
|
r32[i])); |
return jfloatA; | return jfloatA; |
} | } |
break; |
case CIMTYPE_REAL64: |
case CIMTYPE_REAL64: { |
{ |
Array<Real64> r64; | Array<Real64> r64; |
|
|
cv->get(r64); | cv->get(r64); |
|
|
int s=r64.size(); | int s=r64.size(); |
jobjectArray jdoubleA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[7],0); |
jobjectArray jdoubleA = (jobjectArray)jEnv->NewObjectArray (s, |
for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jdoubleA, i, |
JMPIjvm::jv.DoubleClassRef, |
jEnv->NewObject(classRefs[7],instanceMethodIDs[7],r64[i])); |
0); |
|
|
|
for (int i = 0; i < s; i++) |
|
jEnv->SetObjectArrayElement (jdoubleA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.DoubleClassRef, |
|
JMPIjvm::jv.DoubleNewD, |
|
r64[i])); |
return jdoubleA; | return jdoubleA; |
} | } |
break; |
case CIMTYPE_STRING: |
case CIMTYPE_STRING: { |
{ |
Array<String> str; | Array<String> str; |
|
|
cv->get(str); | cv->get(str); |
|
|
int s=str.size(); | int s=str.size(); |
jobjectArray jstringA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[22],0); |
jobjectArray jstringA = (jobjectArray)jEnv->NewObjectArray (s, |
for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jstringA, i, |
JMPIjvm::jv.StringClassRef, |
|
0); |
|
|
|
for (int i = 0; i < s; i++) |
|
jEnv->SetObjectArrayElement (jstringA, |
|
i, |
jEnv->NewStringUTF(str[i].getCString())); | jEnv->NewStringUTF(str[i].getCString())); |
return jstringA; | return jstringA; |
} | } |
break; |
|
case CIMTYPE_REFERENCE: | case CIMTYPE_REFERENCE: |
throwCIMException(jEnv,"+++ Reference not yet supported"); |
{ |
break; |
Array<CIMObjectPath> ref; |
|
|
|
cv->get (ref); |
|
|
|
int s = ref.size (); |
|
jobjectArray jrefA = (jobjectArray)jEnv->NewObjectArray (s, |
|
JMPIjvm::jv.CIMObjectPathClassRef, |
|
0); |
|
|
|
for (int i = 0; i < s; i++) |
|
{ |
|
jint jOP = DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath (ref[i])); |
|
|
|
jEnv->SetObjectArrayElement (jrefA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef, |
|
JMPIjvm::jv.CIMObjectPathNewI, |
|
jOP)); |
|
} |
|
return jrefA; |
|
} |
case CIMTYPE_CHAR16: | case CIMTYPE_CHAR16: |
throwCIMException(jEnv,"+++ Char16 not yet supported"); |
{ |
break; |
Array<Char16> c16; |
|
|
|
cv->get (c16); |
|
|
|
int s = c16.size (); |
|
jobjectArray jc16A = (jobjectArray)jEnv->NewObjectArray (s, |
|
JMPIjvm::jv.CharacterClassRef, |
|
0); |
|
|
|
for (int i = 0; i < s; i++) |
|
jEnv->SetObjectArrayElement (jc16A, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.CharacterClassRef, |
|
JMPIjvm::jv.CharacterNewC, |
|
(jchar)c16[i])); |
|
|
|
return jc16A; |
|
} |
case CIMTYPE_DATETIME: | case CIMTYPE_DATETIME: |
throwCIMException(jEnv,"+++ DateTime not yet supported"); |
{ |
break; |
Array<CIMDateTime> dt; |
|
|
|
cv->get (dt); |
|
|
|
int s = dt.size (); |
|
jobjectArray jdtA = (jobjectArray)jEnv->NewObjectArray (s, |
|
JMPIjvm::jv.CIMDateTimeClassRef, |
|
0); |
|
|
|
for (int i = 0; i < s; i++) |
|
{ |
|
jint jDT = DEBUG_ConvertCToJava (CIMDateTime*, jint, new CIMDateTime (dt[i])); |
|
|
|
jEnv->SetObjectArrayElement (jdtA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef, |
|
JMPIjvm::jv.CIMDateTimeNewI, |
|
jDT)); |
|
} |
|
return jdtA; |
|
} |
case CIMTYPE_OBJECT: | case CIMTYPE_OBJECT: |
throwCIMException(jEnv,"+++ Object not yet supported"); |
{ |
break; |
Array<CIMObject> co; |
|
|
|
cv->get (co); |
|
|
|
int s = co.size (); |
|
jobjectArray jcoA = (jobjectArray)jEnv->NewObjectArray (s, |
|
JMPIjvm::jv.CIMObjectClassRef, |
|
0); |
|
|
|
for (int i = 0; i < s; i++) |
|
{ |
|
if (co[i].isClass ()) |
|
{ |
|
jint jCC = DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass (co[i])); |
|
|
|
jEnv->SetObjectArrayElement (jcoA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef, |
|
JMPIjvm::jv.CIMObjectNewIZ, |
|
jCC, |
|
(jboolean)true)); |
|
} |
|
else |
|
{ |
|
jint jCI = DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance (co[i])); |
|
|
|
jEnv->SetObjectArrayElement (jcoA, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef, |
|
JMPIjvm::jv.CIMObjectNewIZ, |
|
jCI, |
|
(jboolean)false)); |
|
} |
|
} |
|
return jcoA; |
|
} |
default: | default: |
throwCIMException(jEnv,"+++ unsupported type: "); | throwCIMException(jEnv,"+++ unsupported type: "); |
} | } |
|
|
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
_nameSpace::_nameSpace() { |
_nameSpace::_nameSpace () |
|
{ |
port_=0; | port_=0; |
hostName_=System::getHostName(); | hostName_=System::getHostName(); |
nameSpace_="root/cimv2"; | nameSpace_="root/cimv2"; |
} | } |
| |
_nameSpace::_nameSpace(String hn) { |
_nameSpace::_nameSpace (String hn) |
|
{ |
port_=0; | port_=0; |
hostName_=hn; | hostName_=hn; |
nameSpace_="root/cimv2"; | nameSpace_="root/cimv2"; |
} | } |
| |
_nameSpace::_nameSpace(String hn, String ns) { |
_nameSpace::_nameSpace (String hn, String ns) |
|
{ |
port_=0; | port_=0; |
hostName_=hn; | hostName_=hn; |
nameSpace_=ns; | nameSpace_=ns; |
} | } |
| |
int _nameSpace::port() { |
int _nameSpace::port () |
if (port_) return port_; |
{ |
|
if (port_) |
|
return port_; |
port_=5988; | port_=5988; |
if (hostName_.subString(0,7)=="http://") { |
if (hostName_.subString (0,7) == "http://") |
|
{ |
protocol_="http://"; | protocol_="http://"; |
hostName_=hostName_.subString(7); | hostName_=hostName_.subString(7); |
} | } |
Sint32 p=hostName_.reverseFind(':'); | Sint32 p=hostName_.reverseFind(':'); |
if (p>=0) { |
if (p>= 0) |
if (isdigit(hostName_[p+1])) |
{ |
|
if ((hostName_[p+1] >= '0') && (hostName_[p+1] <= '9')) |
port_=atoi(hostName_.subString(p+1).getCString()); | port_=atoi(hostName_.subString(p+1).getCString()); |
hostName_.remove(p); | hostName_.remove(p); |
} | } |
return port_; | return port_; |
} | } |
| |
String _nameSpace::hostName() { |
String _nameSpace::hostName () |
|
{ |
port(); | port(); |
return hostName_; | return hostName_; |
} | } |
| |
String _nameSpace::nameSpace() { |
String _nameSpace::nameSpace () |
|
{ |
return nameSpace_; | return nameSpace_; |
} | } |
| |
|
|
| |
cNs->port_=0; | cNs->port_=0; |
cNs->hostName_=str; | cNs->hostName_=str; |
|
|
jEnv->ReleaseStringUTFChars(jHn,str); | jEnv->ReleaseStringUTFChars(jHn,str); |
} | } |
| |
|
|
const char *str = jEnv->GetStringUTFChars(jN,NULL); | const char *str = jEnv->GetStringUTFChars(jN,NULL); |
| |
cNs->nameSpace_=str; | cNs->nameSpace_=str; |
|
|
jEnv->ReleaseStringUTFChars(jN,str); | jEnv->ReleaseStringUTFChars(jN,str); |
} | } |
| |
|
|
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
void checkNs(CIMObjectPath *cop, jint jNs) { |
void checkNs (CIMObjectPath *cop, jint jNs) |
if (cop->getNameSpace().isNull()) { |
{ |
_nameSpace *ns=(_nameSpace*)jNs; |
if (cop->getNameSpace ().isNull ()) |
cop->setNameSpace(CIMNamespaceName(ns->nameSpace())); |
{ |
|
_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs); |
|
|
|
cop->setNameSpace (CIMNamespaceName (cNs->nameSpace ())); |
} | } |
} | } |
| |
|
|
(JNIEnv *jEnv, jobject jThs, jint jNs, jstring jUn, jstring jPw) | (JNIEnv *jEnv, jobject jThs, jint jNs, jstring jUn, jstring jPw) |
{ | { |
_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs); | _nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs); |
|
|
const char *un=jEnv->GetStringUTFChars(jUn,NULL); | const char *un=jEnv->GetStringUTFChars(jUn,NULL); |
const char *pw=jEnv->GetStringUTFChars(jPw,NULL); | const char *pw=jEnv->GetStringUTFChars(jPw,NULL); |
|
jint jCc = 0; |
| |
try { | try { |
JMPIjvm::cacheIDs(jEnv); |
|
CIMClient *cc=new CIMClient(); | CIMClient *cc=new CIMClient(); |
|
|
cc->connect(cNs->hostName(),cNs->port(),un,pw); | cc->connect(cNs->hostName(),cNs->port(),un,pw); |
jEnv->ReleaseStringUTFChars(jUn,un); |
|
jEnv->ReleaseStringUTFChars(jPw,pw); |
jCc = DEBUG_ConvertCToJava (CIMClient*, jint, cc); |
return DEBUG_ConvertCToJava (CIMClient*, jint, cc); |
|
} | } |
Catch(jEnv); | Catch(jEnv); |
return 0; |
|
|
jEnv->ReleaseStringUTFChars (jUn,un); |
|
jEnv->ReleaseStringUTFChars (jPw,pw); |
|
|
|
return jCc; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1disconnect | JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1disconnect |
|
|
checkNs(cop,jNs); | checkNs(cop,jNs); |
Array<CIMName> enm=cCc->enumerateClassNames(ns,cop->getClassName(),(Boolean)deep); | Array<CIMName> enm=cCc->enumerateClassNames(ns,cop->getClassName(),(Boolean)deep); |
Array<CIMObjectPath> *enmop=new Array<CIMObjectPath>(); | Array<CIMObjectPath> *enmop=new Array<CIMObjectPath>(); |
for (int i=0,m=enm.size(); i<m; i++) { |
for (int i = 0,m = enm.size (); i<m; i++) |
|
{ |
enmop->append(CIMObjectPath(String::EMPTY,ns,enm[i])); | enmop->append(CIMObjectPath(String::EMPTY,ns,enm[i])); |
} | } |
return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, enmop); | return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, enmop); |
|
|
| |
try { | try { |
checkNs(cop,jNs); | checkNs(cop,jNs); |
Array<CIMQualifierDecl> enm=cCc->enumerateQualifiers( |
|
cop->getNameSpace()); |
Array<CIMQualifierDecl> enm = cCc->enumerateQualifiers (cop->getNameSpace ()); |
|
|
return DEBUG_ConvertCToJava (Array<CIMQualifierDecl>*, jint, new Array<CIMQualifierDecl>(enm)); | return DEBUG_ConvertCToJava (Array<CIMQualifierDecl>*, jint, new Array<CIMQualifierDecl>(enm)); |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
|
| |
try { | try { |
checkNs(cop,jNs); | checkNs(cop,jNs); |
CIMInstance inst=cCc->getInstance(cop->getNameSpace(),*cop,(Boolean)lo, |
|
(Boolean)iq,(Boolean)ic,pl); |
CIMInstance inst = cCc->getInstance (cop->getNameSpace (), |
|
*cop, |
|
(Boolean)lo, |
|
(Boolean)iq, |
|
(Boolean)ic, |
|
pl); |
|
|
return DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance(inst)); | return DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance(inst)); |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
|
Catch(jEnv); | Catch(jEnv); |
} | } |
| |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn) | (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn) |
{ | { |
|
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); | CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
const char *str = jEnv->GetStringUTFChars(jPn,NULL); | const char *str = jEnv->GetStringUTFChars(jPn,NULL); |
CIMName pName(str); | CIMName pName(str); |
|
jint jCv = 0; |
| |
jEnv->ReleaseStringUTFChars(jPn,str); |
|
try { | try { |
checkNs(cop,jNs); | checkNs(cop,jNs); |
|
|
CIMValue *val=new CIMValue(cCc->getProperty(cop->getNameSpace(),*cop,pName)); | CIMValue *val=new CIMValue(cCc->getProperty(cop->getNameSpace(),*cop,pName)); |
return DEBUG_ConvertCToJava (CIMValue*, jint, val); |
|
|
jCv = DEBUG_ConvertCToJava (CIMValue*, jint, val); |
} | } |
Catch(jEnv); | Catch(jEnv); |
| |
return 0; |
jEnv->ReleaseStringUTFChars (jPn,str); |
|
|
|
return jCv; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty | JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty |
|
|
const char *str = jEnv->GetStringUTFChars(jPn,NULL); | const char *str = jEnv->GetStringUTFChars(jPn,NULL); |
CIMName pName(str); | CIMName pName(str); |
| |
jEnv->ReleaseStringUTFChars(jPn,str); |
|
try { | try { |
checkNs(cop,jNs); | checkNs(cop,jNs); |
cCc->setProperty(cop->getNameSpace(),*cop,pName,*val); | cCc->setProperty(cop->getNameSpace(),*cop,pName,*val); |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
|
|
jEnv->ReleaseStringUTFChars (jPn,str); |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod | 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) | (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn, jobject jIn, jobject jOut) |
{ | { |
|
JMPIjvm::cacheIDs (jEnv); |
|
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); | CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); | CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
const char *str = jEnv->GetStringUTFChars(jMn,NULL); | const char *str = jEnv->GetStringUTFChars(jMn,NULL); |
CIMName method(str); | CIMName method(str); |
|
jint jCv = 0; |
jEnv->ReleaseStringUTFChars(jMn,str); |
|
|
|
Array<CIMParamValue> in; | Array<CIMParamValue> in; |
Array<CIMParamValue> out; | Array<CIMParamValue> out; |
| |
for (int i=0,m=jEnv->CallIntMethod(jIn,instanceMethodIDs[28]); i<m; i++) { |
for (int i = 0,m = jEnv->CallIntMethod (jIn,JMPIjvm::jv.VectorSize); i<m; i++) |
|
{ |
JMPIjvm::checkException(jEnv); | JMPIjvm::checkException(jEnv); |
| |
jobject jProp=jEnv->CallObjectMethod(jIn,instanceMethodIDs[16],i); |
jobject jProp = jEnv->CallObjectMethod (jIn,JMPIjvm::jv.VectorElementAt,i); |
JMPIjvm::checkException(jEnv); | JMPIjvm::checkException(jEnv); |
| |
jint jp = jEnv->CallIntMethod(jProp,instanceMethodIDs[29]); |
jint jp = jEnv->CallIntMethod (jProp,JMPIjvm::jv.CIMPropertyCInst); |
CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp); | CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp); |
| |
JMPIjvm::checkException(jEnv); | JMPIjvm::checkException(jEnv); |
| |
in.append(CIMParamValue(p->getName().getString(),p->getValue())); | in.append(CIMParamValue(p->getName().getString(),p->getValue())); |
} | } |
|
|
try { | try { |
checkNs(cop,jNs); | checkNs(cop,jNs); |
|
|
CIMValue *val=new CIMValue(cCc->invokeMethod(cop->getNameSpace(),*cop,method,in,out)); | CIMValue *val=new CIMValue(cCc->invokeMethod(cop->getNameSpace(),*cop,method,in,out)); |
| |
for (int i=0,m=out.size(); i<m; i++) { |
for (int i = 0,m = out.size (); i<m; i++) |
|
{ |
const CIMParamValue &parm = out[i]; | const CIMParamValue &parm = out[i]; |
const CIMValue v = parm.getValue(); | const CIMValue v = parm.getValue(); |
CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize()); | CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize()); |
jint jp = DEBUG_ConvertCToJava (CIMProperty*, jint, p); | jint jp = DEBUG_ConvertCToJava (CIMProperty*, jint, p); |
|
jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jp); |
| |
jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],jp); |
jEnv->CallVoidMethod (jOut,JMPIjvm::jv.VectorAddElement,prop); |
|
|
jEnv->CallVoidMethod(jOut,instanceMethodIDs[15],prop); |
|
} | } |
return DEBUG_ConvertCToJava (CIMValue*, jint, val); |
|
|
jCv = DEBUG_ConvertCToJava (CIMValue*, jint, val); |
} | } |
Catch(jEnv); | Catch(jEnv); |
| |
return 0; |
jEnv->ReleaseStringUTFChars (jMn,str); |
} |
|
|
return jCv; |
|
} |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod24 | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod24 |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn, | (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn, |
jobjectArray jIn, jobjectArray jOut) | jobjectArray jIn, jobjectArray jOut) |
{ | { |
|
JMPIjvm::cacheIDs (jEnv); |
|
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); | CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); | CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
const char *str = jEnv->GetStringUTFChars(jMn,NULL); | const char *str = jEnv->GetStringUTFChars(jMn,NULL); |
CIMName method(str); | CIMName method(str); |
|
jint jCv = 0; |
jEnv->ReleaseStringUTFChars(jMn,str); |
|
|
|
Array<CIMParamValue> in; | Array<CIMParamValue> in; |
Array<CIMParamValue> out; | Array<CIMParamValue> out; |
| |
for (int i=0,m=jEnv->GetArrayLength(jIn); i<m; i++) { |
if (jIn) |
|
{ |
|
for (int i = 0,m = jEnv->GetArrayLength (jIn); i<m; i++) |
|
{ |
JMPIjvm::checkException(jEnv); | JMPIjvm::checkException(jEnv); |
| |
jobject jArg=jEnv->GetObjectArrayElement(jIn,i); | jobject jArg=jEnv->GetObjectArrayElement(jIn,i); |
JMPIjvm::checkException(jEnv); | JMPIjvm::checkException(jEnv); |
| |
jint jp = jEnv->CallIntMethod(jArg,instanceMethodIDs[39]); |
jint jp = jEnv->CallIntMethod (jArg,JMPIjvm::jv.CIMArgumentCInst); |
CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jp); | CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jp); |
| |
JMPIjvm::checkException(jEnv); | JMPIjvm::checkException(jEnv); |
| |
in.append(*p); | in.append(*p); |
} | } |
|
} |
try { | try { |
checkNs(cop,jNs); | checkNs(cop,jNs); |
CIMValue *val=new CIMValue(cCc->invokeMethod(cop->getNameSpace(),*cop,method,in,out)); | CIMValue *val=new CIMValue(cCc->invokeMethod(cop->getNameSpace(),*cop,method,in,out)); |
| |
for (int i=0,m=out.size(),o=jEnv->GetArrayLength(jOut); i<m && i<o; i++) { |
if (jOut) |
const CIMParamValue &parm = out[i]; |
{ |
jint jParm = DEBUG_ConvertCToJava (const CIMParamValue*, jint, &parm); |
for (int i = 0,m = out.size (),o = jEnv->GetArrayLength (jOut); i<m && i<o; i++) |
jEnv->SetObjectArrayElement(jOut,i, |
{ |
jEnv->NewObject(classRefs[29],instanceMethodIDs[40],jParm)); |
CIMParamValue *parm = new CIMParamValue (out[i]); |
|
jint jParm = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm); |
|
|
|
jEnv->SetObjectArrayElement (jOut, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.CIMArgumentClassRef,JMPIjvm::jv.CIMArgumentNewI,jParm)); |
} | } |
return DEBUG_ConvertCToJava (CIMValue*, jint, val); |
} |
|
jCv = DEBUG_ConvertCToJava (CIMValue*, jint, val); |
} | } |
Catch(jEnv); | Catch(jEnv); |
| |
return 0; |
jEnv->ReleaseStringUTFChars (jMn,str); |
|
|
|
return jCv; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery |
|
|
const char *str = jEnv->GetStringUTFChars(jQuery,NULL); | const char *str = jEnv->GetStringUTFChars(jQuery,NULL); |
String query(str); | String query(str); |
| |
/* Note: |
/* @NOTE |
** This does not work for some reason on the client java code: | ** This does not work for some reason on the client java code: |
** 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)); | ** 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: | ** What does work is: |
** printf ("This is a test\n"); | ** printf ("This is a test\n"); |
|
** |
|
** To debug these JNI functions insert the following: |
|
** if (getenv ("PEGASUS_JMPI_GDB")) |
|
** { |
|
** bool fLoop = true; |
|
** int i = 0; |
|
** |
|
** while (fLoop) |
|
** { |
|
** 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); | jEnv->ReleaseStringUTFChars(jQuery,str); |
| |
str=jEnv->GetStringUTFChars(jQl,NULL); | str=jEnv->GetStringUTFChars(jQl,NULL); |
|
|
String ql(str); | String ql(str); |
| |
jEnv->ReleaseStringUTFChars(jQl,str); | jEnv->ReleaseStringUTFChars(jQl,str); |
|
|
checkNs(cop,jNs); | checkNs(cop,jNs); |
Array<CIMObject> enm=cCc->execQuery(cop->getNameSpace(),ql,query); | Array<CIMObject> enm=cCc->execQuery(cop->getNameSpace(),ql,query); |
Array<CIMInstance> *enmInst=new Array<CIMInstance>(); | Array<CIMInstance> *enmInst=new Array<CIMInstance>(); |
for (int i=0,m=enm.size(); i<m; i++) { |
for (int i = 0,m = enm.size (); i<m; i++) |
|
{ |
enmInst->append(CIMInstance(enm[i])); | enmInst->append(CIMInstance(enm[i])); |
} | } |
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst); | return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst); |
|
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); | CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); | CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); | const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); |
CIMName assocClass(str); |
|
|
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); | jEnv->ReleaseStringUTFChars(jAssocClass,str); |
|
|
str=jEnv->GetStringUTFChars(jResultClass,NULL); | str=jEnv->GetStringUTFChars(jResultClass,NULL); |
| |
CIMName resultClass(str); |
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); | jEnv->ReleaseStringUTFChars(jResultClass,str); |
|
|
str=jEnv->GetStringUTFChars(jRole,NULL); | str=jEnv->GetStringUTFChars(jRole,NULL); |
| |
String role(str); | String role(str); |
| |
jEnv->ReleaseStringUTFChars(jRole,str); | jEnv->ReleaseStringUTFChars(jRole,str); |
|
|
str=jEnv->GetStringUTFChars(jResultRole,NULL); | str=jEnv->GetStringUTFChars(jResultRole,NULL); |
| |
String resultRole(str); | String resultRole(str); |
|
|
| |
try { | try { |
checkNs(cop,jNs); | checkNs(cop,jNs); |
Array<CIMObjectPath> enm=cCc->associatorNames( |
|
cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole); |
Array<CIMObjectPath> enm = cCc->associatorNames (cop->getNameSpace (), |
|
*cop, |
|
assocClass, |
|
resultClass, |
|
role, |
|
resultRole); |
return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm)); | return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm)); |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); | CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
CIMPropertyList pl = getList(jEnv,jPl); | CIMPropertyList pl = getList(jEnv,jPl); |
const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); | const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); |
CIMName assocClass(str); |
|
|
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); | jEnv->ReleaseStringUTFChars(jAssocClass,str); |
|
|
str=jEnv->GetStringUTFChars(jResultClass,NULL); | str=jEnv->GetStringUTFChars(jResultClass,NULL); |
| |
CIMName resultClass(str); |
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); | jEnv->ReleaseStringUTFChars(jResultClass,str); |
|
|
str=jEnv->GetStringUTFChars(jRole,NULL); | str=jEnv->GetStringUTFChars(jRole,NULL); |
| |
String role(str); | String role(str); |
| |
jEnv->ReleaseStringUTFChars(jRole,str); | jEnv->ReleaseStringUTFChars(jRole,str); |
|
|
str=jEnv->GetStringUTFChars(jResultRole,NULL); | str=jEnv->GetStringUTFChars(jResultRole,NULL); |
| |
String resultRole(str); | String resultRole(str); |
|
|
| |
try { | try { |
checkNs(cop,jNs); | checkNs(cop,jNs); |
Array<CIMObject> enm=cCc->associators( |
|
cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole, |
Array<CIMObject> enm = cCc->associators (cop->getNameSpace (), |
(Boolean)includeQualifiers,(Boolean)includeClassOrigin,pl); |
*cop, |
|
assocClass, |
|
resultClass, |
|
role, |
|
resultRole, |
|
(Boolean)includeQualifiers, |
|
(Boolean)includeClassOrigin, |
|
pl); |
Array<CIMInstance> *enmInst=new Array<CIMInstance>(); | Array<CIMInstance> *enmInst=new Array<CIMInstance>(); |
for (int i=0,m=enm.size(); i<m; i++) { |
|
|
for (int i = 0,m = enm.size (); i<m; i++) |
|
{ |
enmInst->append(CIMInstance(enm[i])); | enmInst->append(CIMInstance(enm[i])); |
} | } |
|
|
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst); | return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst); |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); | CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); | CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); | const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); |
CIMName assocClass(str); |
|
|
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); | jEnv->ReleaseStringUTFChars(jAssocClass,str); |
|
|
str=jEnv->GetStringUTFChars(jRole,NULL); | str=jEnv->GetStringUTFChars(jRole,NULL); |
| |
String role(str); | String role(str); |
|
|
| |
try { | try { |
checkNs(cop,jNs); | checkNs(cop,jNs); |
Array<CIMObjectPath> enm=cCc->referenceNames( |
|
cop->getNameSpace(),*cop,assocClass,role); |
Array<CIMObjectPath> enm = cCc->referenceNames (cop->getNameSpace (), |
|
*cop, |
|
assocClass, |
|
role); |
|
|
return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm)); | return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm)); |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
|
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); | CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
CIMPropertyList pl = getList(jEnv,jPl); | CIMPropertyList pl = getList(jEnv,jPl); |
const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); | const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL); |
CIMName assocClass(str); |
|
|
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); | jEnv->ReleaseStringUTFChars(jAssocClass,str); |
str=jEnv->GetStringUTFChars(jRole,NULL); | str=jEnv->GetStringUTFChars(jRole,NULL); |
|
|
| |
try { | try { |
checkNs(cop,jNs); | checkNs(cop,jNs); |
Array<CIMObject> enm=cCc->references( |
Array<CIMObject> enm = cCc->references (cop->getNameSpace (), |
cop->getNameSpace(),*cop,assocClass,role, |
*cop, |
(Boolean)includeQualifiers,(Boolean)includeClassOrigin,pl); |
assocClass, |
|
role, |
|
(Boolean)includeQualifiers, |
|
(Boolean)includeClassOrigin, |
|
pl); |
Array<CIMInstance> *enmInst=new Array<CIMInstance>(); | Array<CIMInstance> *enmInst=new Array<CIMInstance>(); |
for (int i=0,m=enm.size(); i<m; i++) { |
|
|
for (int i = 0,m = enm.size (); i<m; i++) |
|
{ |
enmInst->append(CIMInstance(enm[i])); | enmInst->append(CIMInstance(enm[i])); |
} | } |
|
|
return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst); | return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst); |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
|
return 0; | return 0; |
} | } |
| |
static int normalizeNs(String &ns, String &nsBase, String &lastNsComp) { |
static int normalizeNs (String &ns, String &nsBase, String &lastNsComp) |
|
{ |
Uint32 n=ns.size(); | Uint32 n=ns.size(); |
if (ns[n-1]=='/') { |
if (ns[n-1] == '/') |
|
{ |
if (n>=2) ns=ns.subString(0,n-2); | if (n>=2) ns=ns.subString(0,n-2); |
} | } |
| |
|
|
nsBase="root"; | nsBase="root"; |
| |
n=ns.reverseFind('/'); | n=ns.reverseFind('/'); |
if (n!=PEG_NOT_FOUND) { |
if (n!= PEG_NOT_FOUND) |
|
{ |
lastNsComp=ns.subString(n+1); | lastNsComp=ns.subString(n+1); |
nsBase=ns.subString(0,n); | nsBase=ns.subString(0,n); |
} | } |
|
|
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateNameSpaces | JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateNameSpaces |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jboolean deep, jobject jVec) | (JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jboolean deep, jobject jVec) |
{ | { |
|
JMPIjvm::cacheIDs (jEnv); |
|
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); | CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); | CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop); |
String ns = cop->getNameSpace().getString(); | String ns = cop->getNameSpace().getString(); |
|
|
try { | try { |
Array<CIMObjectPath> enm=cCc->enumerateInstanceNames( | Array<CIMObjectPath> enm=cCc->enumerateInstanceNames( |
cop->getNameSpace(),CIMName("__Namespace")); | cop->getNameSpace(),CIMName("__Namespace")); |
for (int i=0,s=enm.size(); i<s; i++) { |
for (int i = 0, s = enm.size (); i < s; i++) |
|
{ |
CIMObjectPath &cop=enm[i]; | CIMObjectPath &cop=enm[i]; |
const Array<CIMKeyBinding>& kb=cop.getKeyBindings(); | const Array<CIMKeyBinding>& kb=cop.getKeyBindings(); |
const String &n=kb[0].getValue(); | const String &n=kb[0].getValue(); |
|
|
continue; | continue; |
String x=ns+"/"+n; | String x=ns+"/"+n; |
jstring str=jEnv->NewStringUTF(x.getCString()); | jstring str=jEnv->NewStringUTF(x.getCString()); |
jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],str); |
jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,str); |
} | } |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
|
Catch(jEnv); | Catch(jEnv); |
} | } |
| |
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1finalize |
|
(JNIEnv *jEnv, jobject jThs, jint jCc) |
|
{ |
|
CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc); |
|
|
|
delete cCc; |
|
|
|
DEBUG_ConvertCleanup (jint, jCc); |
|
} |
|
|
|
// ------------------------------------- |
|
// --- |
|
// - CIMObject |
|
// --- |
|
// ------------------------------------- |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObject__1newClass |
|
(JNIEnv *jEnv, jobject jThs, jint jCc) |
|
{ |
|
CIMClass *cCc = DEBUG_ConvertJavaToC (jint, CIMClass*, jCc); |
|
|
|
try { |
|
CIMObject *cCo = new CIMObject (*cCc); |
|
|
|
return DEBUG_ConvertCToJava (CIMObject*, jint, cCo); |
|
} |
|
Catch (jEnv); |
|
|
|
return 0; |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObject__1newInstance |
|
(JNIEnv *jEnv, jobject jThs, jint jCi) |
|
{ |
|
CIMInstance *cCi = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi); |
|
|
|
try { |
|
CIMObject *cCo = new CIMObject (*cCi); |
|
|
|
return DEBUG_ConvertCToJava (CIMObject*, jint, cCo); |
|
} |
|
Catch (jEnv); |
|
|
|
return 0; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObject__1finalize |
|
(JNIEnv *jEnv, jobject jThs, jint jInst) |
|
{ |
|
CIMObject *co = DEBUG_ConvertJavaToC (jint, CIMObject*, jInst); |
|
|
|
delete co; |
|
|
|
DEBUG_ConvertCleanup (jint, jInst); |
|
} |
|
|
|
// ------------------------------------- |
|
// --- |
|
// - OperationContext |
|
// --- |
|
// ------------------------------------- |
|
|
|
/* |
|
* Class: OperationContext |
|
* Method: _get |
|
* Signature: (ILjava/lang/String;Ljava/lang/String;)Ljava/lang/Object; |
|
*/ |
|
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_OperationContext__1get |
|
(JNIEnv *jEnv, jobject jThs, jint jInst, jstring jContainer, jstring jKey) |
|
{ |
|
OperationContext *poc = DEBUG_ConvertJavaToC (jint, OperationContext*, jInst); |
|
jobject jRet = 0; |
|
|
|
if (!poc) |
|
{ |
|
return jRet; |
|
} |
|
|
|
const char *pszContainer = jEnv->GetStringUTFChars (jContainer, NULL); |
|
const char *pszKey = jEnv->GetStringUTFChars (jKey, NULL); |
|
String container (pszContainer); |
|
String key (pszKey); |
|
|
|
///printf ("container: %s\n", pszContainer); |
|
///printf ("key: %s\n", pszKey); |
|
|
|
try { |
|
if (container == "IdentityContainer") |
|
{ |
|
IdentityContainer ic = poc->get (IdentityContainer::NAME); |
|
|
|
/////////printf ("ic\n"); |
|
|
|
if (key == "userName") |
|
{ |
|
String userName = ic.getUserName (); |
|
|
|
////////////printf ("userName: %s\n", (const char*)userName.getCString ()); |
|
|
|
jRet = jEnv->NewStringUTF ((const char*)userName.getCString ()); |
|
} |
|
} |
|
else if (container == "SubscriptionInstanceContainer") |
|
{ |
|
SubscriptionInstanceContainer sic = poc->get (SubscriptionInstanceContainer::NAME); |
|
|
|
if (key == "subscriptionInstance") |
|
{ |
|
CIMInstance ci = sic.getInstance (); |
|
jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance (ci)); |
|
|
|
jRet = jEnv->NewObject (JMPIjvm::jv.CIMInstanceClassRef, |
|
JMPIjvm::jv.CIMInstanceNewI, |
|
jciRef); |
|
} |
|
} |
|
else if (container == "SubscriptionInstanceNamesContainer") |
|
{ |
|
SubscriptionInstanceNamesContainer sinc = poc->get (SubscriptionInstanceNamesContainer::NAME); |
|
|
|
if (key == "subscriptionInstanceNames") |
|
{ |
|
Array<CIMObjectPath> copa = sinc.getInstanceNames (); |
|
jobjectArray jcopa = 0; |
|
int jcopaLength = copa.size (); |
|
|
|
jcopa = jEnv->NewObjectArray (jcopaLength, |
|
JMPIjvm::jv.CIMObjectPathClassRef, |
|
0); |
|
|
|
for (int i = 0; i < jcopaLength; i++) |
|
{ |
|
jEnv->SetObjectArrayElement (jcopa, |
|
i, |
|
jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef, |
|
JMPIjvm::jv.CIMObjectPathNewI, |
|
new CIMObjectPath (copa[i]))); |
|
} |
|
|
|
jRet = (jobject)jcopa; |
|
} |
|
} |
|
else if (container == "SubscriptionFilterConditionContainer") |
|
{ |
|
SubscriptionFilterConditionContainer sfcc = poc->get (SubscriptionFilterConditionContainer::NAME); |
|
|
|
/////////printf ("sfcc\n"); |
|
|
|
if (key == "filterCondition") |
|
{ |
|
String filterCondition = sfcc.getFilterCondition (); |
|
|
|
////////////printf ("filterCondition: %s\n", (const char*)filterCondition.getCString ()); |
|
|
|
jRet = jEnv->NewStringUTF ((const char*)filterCondition.getCString ()); |
|
} |
|
else if (key == "queryLanguage") |
|
{ |
|
String queryLanguage = sfcc.getQueryLanguage (); |
|
|
|
jRet = jEnv->NewStringUTF ((const char*)queryLanguage.getCString ()); |
|
} |
|
} |
|
else if (container == "SubscriptionFilterQueryContainer") |
|
{ |
|
SubscriptionFilterQueryContainer sfqc = poc->get (SubscriptionFilterQueryContainer::NAME); |
|
|
|
if (key == "filterQuery") |
|
{ |
|
String filterQuery = sfqc.getFilterQuery (); |
|
|
|
jRet = jEnv->NewStringUTF ((const char*)filterQuery.getCString ()); |
|
} |
|
else if (key == "queryLanguage") |
|
{ |
|
String queryLanguage = sfqc.getQueryLanguage (); |
|
|
|
jRet = jEnv->NewStringUTF ((const char*)queryLanguage.getCString ()); |
|
} |
|
else if (key == "sourceNameSpace") |
|
{ |
|
CIMNamespaceName cimNameSpaceName = sfqc.getSourceNameSpace (); |
|
String nameSpaceName = cimNameSpaceName.getString (); |
|
|
|
jRet = jEnv->NewStringUTF ((const char*)nameSpaceName.getCString ()); |
|
} |
|
} |
|
else if (container == "SnmpTrapOidContainer") |
|
{ |
|
SnmpTrapOidContainer stoc = poc->get (SnmpTrapOidContainer::NAME); |
|
|
|
if (key == "snmpTrapOid") |
|
{ |
|
String snmpTrapOid = stoc.getSnmpTrapOid (); |
|
|
|
jRet = jEnv->NewStringUTF ((const char*)snmpTrapOid.getCString ()); |
|
} |
|
} |
|
} |
|
Catch (jEnv); |
|
|
|
///printf ("jRet: %08X\n", (int)jRet); |
|
|
|
jEnv->ReleaseStringUTFChars (jContainer, pszContainer); |
|
jEnv->ReleaseStringUTFChars (jKey, pszKey); |
|
|
|
return jRet; |
|
} |
|
|
|
// ------------------------------------- |
|
// --- |
|
// - SelectExp |
|
// --- |
|
// ------------------------------------- |
|
|
|
/* |
|
* Class: org_pegasus_jmpi_SelectExp |
|
* Method: _finalize |
|
* Signature: (I)V |
|
*/ |
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_SelectExp__1finalize |
|
(JNIEnv *jEnv, jobject jThs, jint jWQLStmt) |
|
{ |
|
WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jint, WQLSelectStatement*, jWQLStmt); |
|
|
|
delete wql_stmt; |
|
|
|
DEBUG_ConvertCleanup (jint, jWQLStmt); |
|
} |
|
|
|
/* |
|
* Class: org_pegasus_jmpi_SelectExp |
|
* 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); |
|
WQLSelectStatement *wql_stmt = NULL; |
|
String queryLanguage (CALL_SIGN_WQL); |
|
String query (pszQuery); |
|
|
|
wql_stmt = new WQLSelectStatement (queryLanguage, query); |
|
DDD (PEGASUS_STD (cout)<<"--- Java_org_pegasus_jmpi_SelectExp__1newSelectExp: wql_stmt = "<<PEGASUS_STD (hex)<< (int)wql_stmt<<PEGASUS_STD (dec)<<PEGASUS_STD (endl)); |
|
|
|
try |
|
{ |
|
WQLParser::parse (query, *wql_stmt); |
|
} |
|
catch (const Exception &e) |
|
{ |
|
cerr << "Java_org_pegasus_jmpi_SelectExp__1newSelectExp: Caught: " << e.getMessage () << endl; |
|
} |
|
|
|
jEnv->ReleaseStringUTFChars (jQuery, pszQuery); |
|
|
|
return DEBUG_ConvertCToJava (WQLSelectStatement *, jint, wql_stmt); |
|
} |
|
|
|
/* |
|
* Class: org_pegasus_jmpi_SelectExp |
|
* Method: _getSelectString |
|
* Signature: (I)Ljava/lang/String; |
|
*/ |
|
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_SelectExp__1getSelectString |
|
(JNIEnv *jEnv, jobject jThs, jint jWQLStmt) |
|
{ |
|
WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jint, WQLSelectStatement*, jWQLStmt); |
|
String cond; |
|
|
|
if (wql_stmt) |
|
{ |
|
try |
|
{ |
|
cond = wql_stmt->getQuery (); |
|
} |
|
catch (const Exception &e) |
|
{ |
|
cerr << "Java_org_pegasus_jmpi_SelectExp__1getSelectString: Caught: " << e.getMessage () << endl; |
|
|
|
cond = ""; |
|
} |
|
} |
|
else |
|
{ |
|
cond = ""; |
|
} |
|
|
|
return (jstring)jEnv->NewStringUTF (cond.getCString ()); |
|
} |
|
|
|
// ------------------------------------- |
|
// --- |
|
// - JMPISelectList |
|
// --- |
|
// ------------------------------------- |
|
|
|
/* |
|
* Class: org_pegasus_jmpi_JMPISelectList |
|
* Method: _applyInstance |
|
* Signature: (II)I |
|
*/ |
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyInstance |
|
(JNIEnv *jEnv, jobject jThs, jint jWQLStmt, jint jciInstance) |
|
{ |
|
WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jint, WQLSelectStatement*, jWQLStmt); |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciInstance); |
|
CIMInstance *ciRet = 0; |
|
|
|
if ( !wql_stmt |
|
|| !ci |
|
) |
|
{ |
|
return 0; |
|
} |
|
|
|
ciRet = new CIMInstance (ci->clone ()); |
|
|
|
if (ciRet) |
|
{ |
|
try |
|
{ |
|
wql_stmt->applyProjection (*ciRet, false); |
|
} |
|
catch (const Exception &e) |
|
{ |
|
cerr << "Java_org_pegasus_jmpi_JMPISelectList__1applyInstance: Caught: " << e.getMessage () << endl; |
|
|
|
return 0; |
|
} |
|
} |
|
|
|
return DEBUG_ConvertCToJava (CIMInstance *, jint, ciRet); |
|
} |
|
|
|
/* |
|
* Class: org_pegasus_jmpi_JMPISelectList |
|
* Method: _applyClass |
|
* Signature: (II)I |
|
*/ |
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyClass |
|
(JNIEnv *jEnv, jobject jThs, jint jWQLStmt, jint jciClass) |
|
{ |
|
WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jint, WQLSelectStatement*, jWQLStmt); |
|
CIMClass *cc = DEBUG_ConvertJavaToC (jint, CIMClass*, jciClass); |
|
CIMClass *ccRet = NULL; |
|
|
|
if (!wql_stmt) |
|
{ |
|
return 0; |
|
} |
|
|
|
if (cc) |
|
{ |
|
CIMObject co (cc->clone ()); |
|
|
|
try |
|
{ |
|
wql_stmt->applyProjection (co, false); |
|
} |
|
catch (const Exception &e) |
|
{ |
|
cerr << "Java_org_pegasus_jmpi_JMPISelectList__1applyClass: Caught: " << e.getMessage () << endl; |
|
|
|
return 0; |
|
} |
|
|
|
ccRet = new CIMClass (co); |
|
|
|
return DEBUG_ConvertCToJava (CIMClass *, jint, ccRet); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
// ------------------------------------- |
|
// --- |
|
// - JMPIQueryExp |
|
// --- |
|
// ------------------------------------- |
|
|
|
/* |
|
* Class: org_pegasus_jmpi_JMPIQueryExp |
|
* Method: _applyInstance |
|
* Signature: (II)Z |
|
*/ |
|
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_JMPIQueryExp__1applyInstance |
|
(JNIEnv *jEnv, jobject jThs, jint jWQLStmt, jint jciInstance) |
|
{ |
|
WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jint, WQLSelectStatement*, jWQLStmt); |
|
CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciInstance); |
|
|
|
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; |
|
|
|
return false; |
|
} |
|
} |
|
|
} // extern "C" | } // extern "C" |
| |
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |