pegasus/src/Pegasus/ProviderManager2/JMPI/JMPIImpl.cpp - diff

Return to JMPIImpl.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI

Diff for /pegasus/src/Pegasus/ProviderManager2/JMPI/JMPIImpl.cpp between version 1.22 and 1.33

version 1.22, 2005/05/23 20:43:47

version 1.33, 2005/12/22 01:59:24

Line 34

// Magda Vacarelu

// David Dillard, VERITAS Software Corp.

// (david.dillard@veritas.com)

// Mark Hamzy

// Mark Hamzy, hamzy@us.ibm.com

//%/////////////////////////////////////////////////////////////////////////////

Line 68

JvmVector JMPIjvm::jv;

int JMPIjvm::trace=0;

#ifdef PEGASUS_DEBUG

#define DDD(x) if (JMPIjvm::trace) x;

#else

#define DDD(x)

#endif

#include "Convert.h"

JMPIjvm::ClassTable JMPIjvm::_classTable;

JMPIjvm::ObjectTable JMPIjvm::_objectTable;

typedef struct {

int clsIndex;

const char * methodName;

const char * signature;

} METHOD_STRUCT;

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

};

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" },

/*45*/ { 13,"<init>", "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V" },

};

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;

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);

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getGlobalClassRef: localRefCls = "<<PEGASUS_STD(hex)<<(int)localRefCls<<PEGASUS_STD(dec)<<", name = "<<name<<PEGASUS_STD(endl));

if (localRefCls==NULL)

return JNI_FALSE;

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);

return globalRefCls;

}

JMPIjvm::JMPIjvm() {

JMPIjvm::JMPIjvm()

{

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)

Line 215

Line 219

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));

if ((classRefs[i]=getGlobalClassRef(env,classNames[i]))==NULL)

{

Line 225

Line 229

}

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],

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));

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],

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));

return 0;

Line 247

Line 253

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;

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()

Line 263

Line 278

#ifdef JAVA_DESTROY_VM_WORKS

if (jvm!=NULL) {

JvmVector *jv;

attachThread(&jv);

jvm->DestroyJavaVM();

jvm=NULL;

return 0;

}

#endif

Line 273

Line 292

return -1;

}

Mutex JMPIjvm::_initMutex;

int JMPIjvm::initJVM()

{

AutoMutex lock (_initMutex);

if (jvm != NULL)

{

return 0;

}

JavaVMInitArgs vm_args;

jint res;

char *envstring;

JNIEnv *env;

JavaVMOption *poptions = 0;

int maxoption = 0;

typedef struct _JVMOptions {

const char *pszEnvName;

const char *pszPrefix;

bool fSplit;

} JVMOPTIONS;

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;

Line 313

Line 347

///JNIoptions.append ("-Djava.compiler=NONE");

///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 (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++;

oss.str ("");

oss << aENVoptions[i][1] << envstring;

oss << pEnvOption->pszPrefix << envstring;

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));

}

Line 348

Line 421

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.nOptions=maxoption;

vm_args.ignoreUnrecognized=JNI_TRUE;

Line 361

Line 434

}

if (res!=0) {

jv.initRc=1;

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;

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;

}

JNIEnv* JMPIjvm::attachThread(JvmVector **jvp) {

JNIEnv* JMPIjvm::attachThread(JvmVector **jvp)

JNIEnv* env;

{

if (jvm==NULL) initJVM();

JNIEnv* env = NULL;

if (jvm == NULL)

{

initJVM ();

if (jvm == NULL)

return NULL;

}

jvm->AttachCurrentThread((void**)&env,NULL);

*jvp=&jv;

return env;

}

void JMPIjvm::detachThread() {

void JMPIjvm::detachThread()

{

jvm->DetachCurrentThread();

}

Line 417

Line 516

jstring jjar=env->NewStringUTF((const char*)jar.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,jv.JarClassLoaderLoad,

jjar,jcln);

if (env->ExceptionCheck()) {

env->ExceptionDescribe();

Line 541

Line 640

}

else {

DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::checkException: exiting..."<<PEGASUS_STD(endl));

env->ExceptionDescribe();

exit(13);

}

Line 607

Line 707

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;

}

extern "C" {

Line 614

Line 735

void throwCimException(JNIEnv *jEnv, CIMException & e) {

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);

}

void throwFailedException(JNIEnv *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);

}

void throwNotSupportedException(JNIEnv *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);

}

Line 641

Line 762

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1new

(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

(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

(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

(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

(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);

}

Line 672

Line 798

// ---

// -------------------------------------

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

(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean lo,

jboolean iq, jboolean ic, jobjectArray jPl)

Line 766

Line 877

OperationContext ctx;

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>();

for (int i=0,m=enm.size(); i<m; i++) {

Line 792

Line 903

Array<CIMClass> en=ch->enumerateClasses(ctx,

cop->getNameSpace(),

cop->getClassName(),

deep,

(Boolean)deep,

(Boolean)lo,

iq,

(Boolean)iq,

ic);

(Boolean)ic);

return DEBUG_ConvertCToJava (Array<CIMClass>*, jint, new Array<CIMClass>(en));

}

Line 919

Line 1030

Array<CIMInstance> en=ch->enumerateInstances(ctx,

cop->getNameSpace(),

cop->getClassName(),

deep,

(Boolean)deep,

lo,

(Boolean)lo,

iq,

(Boolean)iq,

ic,

(Boolean)ic,

pl);

return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, new Array<CIMInstance>(en));

}

Line 941

Line 1052

String query(str);

jEnv->ReleaseStringUTFChars(jQuery,str);

str=jEnv->GetStringUTFChars(jQl,NULL);

String ql(str);

Line 970

Line 1082

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

OperationContext ctx;

const char *str = jEnv->GetStringUTFChars(jN,NULL);

CIMName prop(str);

jEnv->ReleaseStringUTFChars(jN,str);

try {

CIMName prop(str);

CIMValue *cv = new CIMValue(ch->getProperty(ctx, cop->getNameSpace(),*cop,prop));

jEnv->ReleaseStringUTFChars(jN,str);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

Line 994

Line 1107

CIMName pName(str);

jEnv->ReleaseStringUTFChars(jPn,str);

try {

ch->setProperty(ctx,cop->getNameSpace(),*cop,pName,*val);

}

Line 1003

Line 1117

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod

(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jMn, jobject jIn, jobject jOut)

{

JMPIjvm::cacheIDs(jEnv);

CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

OperationContext ctx;

Line 1014

Line 1130

Array<CIMParamValue> in;

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);

jobject jProp=jEnv->CallObjectMethod(jIn,instanceMethodIDs[16],i);

jobject jProp = jEnv->CallObjectMethod(jIn,JMPIjvm::jv.VectorElementAt,i);

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);

JMPIjvm::checkException(jEnv);

Line 1035

Line 1152

const CIMValue v = parm.getValue();

CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize());

jint jp = DEBUG_ConvertCToJava (CIMProperty*, jint, p);

jobject prop = jEnv->NewObject(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);

}

Line 1050

Line 1167

(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jMn,

jobjectArray jIn, jobjectArray jOut)

{

JMPIjvm::cacheIDs(jEnv);

CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

OperationContext ctx;

Line 1067

Line 1186

jobject jArg=jEnv->GetObjectArrayElement(jIn,i);

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);

JMPIjvm::checkException(jEnv);

Line 1078

Line 1197

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++) {

const CIMParamValue &parm = out[i];

CIMParamValue *parm = new CIMParamValue (out[i]);

jint jParm = DEBUG_ConvertCToJava (const CIMParamValue*, jint, &parm);

jint jParm = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);

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);

}

Line 1099

Line 1218

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

OperationContext ctx;

const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL);

CIMName assocClass(str);

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 {

Array<CIMObjectPath> enm=ch->associatorNames(ctx,

cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole);

cop->getNameSpace(),

*cop,

assocClass,

resultClass,

role,

resultRole);

return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm));

}

Catch(jEnv);

Line 1122

Line 1256

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,

jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole,

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)

Line 1132

Line 1266

OperationContext ctx;

CIMPropertyList pl = getList(jEnv,jPl);

const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL);

CIMName assocClass(str);

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 {

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>();

for (int i=0,m=enm.size(); i<m; i++) {

enmInst->append(CIMInstance(enm[i]));

}

return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);

}

Catch(jEnv);

Line 1168

Line 1320

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

OperationContext ctx;

const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL);

CIMName assocClass(str);

jEnv->ReleaseStringUTFChars(jAssocClass,str);

str=jEnv->GetStringUTFChars(jRole,NULL);

String role(str);

jEnv->ReleaseStringUTFChars(jRole,str);

try {

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));

}

Catch(jEnv);

Line 1198

Line 1357

CIMName assocClass(str);

jEnv->ReleaseStringUTFChars(jAssocClass,str);

str=jEnv->GetStringUTFChars(jRole,NULL);

String role(str);

Line 1206

Line 1366

try {

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>();

for (int i=0,m=enm.size(); i<m; i++) {

enmInst->append(CIMInstance(enm[i]));

}

return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);

}

Catch(jEnv);

Line 1228

Line 1395

String name(str);

jEnv->ReleaseStringUTFChars(jName,str);

str=jEnv->GetStringUTFChars(jNs,NULL);

String ns(str);

Line 1288

Line 1456

}

for (int i=0,m=cls->getPropertyCount(); i<m; i++) {

CIMProperty cp= cls->getProperty(i);

ci->addProperty(cp.clone());

for (int j=0, s=cp.getQualifierCount(); j<s; j++) {

try {

ci->getProperty(i).addQualifier(cp.getQualifier(j));

Line 1296

Line 1466

catch (Exception e) {}

}

return DEBUG_ConvertCToJava (CIMInstance*, jint, ci);

}

Catch(jEnv);

Line 1366

Line 1537

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties

(JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec)

{

JMPIjvm::cacheIDs(jEnv);

CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);

for (int i=0,s=cls->getPropertyCount(); i<s; i++) {

CIMProperty *cp = new CIMProperty(cls->getProperty(i));

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;

Line 1392

Line 1565

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1setProperties

(JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec)

{

JMPIjvm::cacheIDs(jEnv);

CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);

for (int i=cls->getPropertyCount()-1; i>=0; 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);

jobject o=jEnv->CallObjectMethod(jVec,instanceMethodIDs[16],(i));

jobject o=jEnv->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,(i));

jint jp = jEnv->CallIntMethod(o,instanceMethodIDs[29]);

jint jp = jEnv->CallIntMethod(o,JMPIjvm::jv.CIMPropertyCInst);

CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp);

JMPIjvm::checkException(jEnv);

Line 1415

Line 1590

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifiers

(JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec)

{

JMPIjvm::cacheIDs(jEnv);

CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);

for (int i=0,s=cls->getQualifierCount(); i<s; i++) {

CIMQualifier *cq = new CIMQualifier(cls->getQualifier(i));

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;

Line 1453

Line 1630

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getKeys

(JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec)

{

JMPIjvm::cacheIDs(jEnv);

CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);

if (cls->hasKeys()) {

Line 1464

Line 1643

CIMProperty *cp = new CIMProperty(cls->getProperty(pos));

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);

}

Line 1519

Line 1698

if (lo) {

cf=new CIMClass(cc->clone());

CIMName clsn=cc->getClassName();

for (int i=cf->getPropertyCount()-1; i>=0; i--)

if (cf->getProperty(i).getClassOrigin()==clsn) cf->removeProperty(i);

return DEBUG_ConvertCToJava (CIMClass*, jint, cf);

}

else if (jPl) {

CIMPropertyList pl=getList(jEnv,jPl);

Array<CIMName> n=pl.getPropertyNameArray();

cf=new CIMClass(clsn, cc->getSuperClassName());

for (int i=0,s=n.size(); i<s; i++) {

Uint32 pos=cc->findProperty(n[i]);

if (pos!=PEG_NOT_FOUND) {

if (iq) {

CIMProperty cp=cc->getProperty(pos).clone();

if (!ic) cp.setClassOrigin(CIMName());

if (!ic)

cp.setClassOrigin(CIMName());

cf->addProperty(cp);

}

else {

CIMProperty cp=cc->getProperty(pos);

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);

}

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));

}

else if (iq) {

cf=new CIMClass(cc->clone());

if (ic) return DEBUG_ConvertCToJava (CIMClass*, jint, cf);

if (ic)

return DEBUG_ConvertCToJava (CIMClass*, jint, cf);

for (int i=cf->getPropertyCount()-1; i>=0; i--) {

CIMProperty cp=cf->getProperty(i);

cp.setClassOrigin(CIMName());

cf->removeProperty(i);

cf->addProperty(cp);

Line 1561

Line 1762

}

else {

cf=new CIMClass(clsn, cc->getSuperClassName());

for (int i=cc->getPropertyCount()-1; i>=0; i--) {

CIMProperty cp=cc->getProperty(i);

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);

}

Line 1592

Line 1802

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

const char *str=jEnv->GetStringUTFChars(jN,NULL);

CIMInstance *ci = new CIMInstance(CIMName(str));

return DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance(CIMName(str)));

jEnv->ReleaseStringUTFChars(jN,str);

return DEBUG_ConvertCToJava (CIMInstance*, jint, ci);

}

//Added by Andy Viciu

Line 1603

Line 1816

CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);

const char *str = jEnv->GetStringUTFChars(jN,NULL);

jEnv->ReleaseStringUTFChars(jN,str);

/* NOT SUPPORTED AND NOT NEEDED*/

}

Line 1615

Line 1830

Uint32 pos = ci->findProperty(CIMName(str));

try {

if (pos!=PEG_NOT_FOUND) {

if (pos!=PEG_NOT_FOUND)

{

CIMProperty cp=ci->getProperty(pos);

if (cp.getType()==cv->getType())

{

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 : "<<cp.getType()<<" <> "<<cv->getType()<<PEGASUS_STD(endl));

throw CIMException(CIM_ERR_FAILED, String("Type mismatch"));

}

ci->removeProperty(pos);

ci->addProperty(cp);

}

else {

else

{

CIMProperty *cp=new CIMProperty(CIMName(str),*cv);

ci->addProperty(*cp);

}

Line 1653

Line 1875

try {

Uint32 pos=ci->findProperty(CIMName(str));

if (pos!=PEG_NOT_FOUND) {

if (pos != PEG_NOT_FOUND)

{

CIMProperty *cp=new CIMProperty(ci->getProperty(pos));

rv = DEBUG_ConvertCToJava (CIMProperty*, jint, cp);

}

Line 1668

Line 1893

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getKeyValuePairs

(JNIEnv *jEnv, jobject jThs, jint jInst, jobject jVec)

{

JMPIjvm::cacheIDs(jEnv);

CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);

for (int i=0,s=ci->getPropertyCount(); i<s; i++) {

Line 1675

Line 1902

CIMProperty *cp = new CIMProperty(ci->getProperty(i));

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);

}

Line 1703

Line 1930

jint rv = -1;

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)));

}

Line 1724

Line 1952

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperties

(JNIEnv *jEnv, jobject jThs, jint jInst, jobject jVec)

{

JMPIjvm::cacheIDs(jEnv);

CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);

for (int i=0,s=ci->getPropertyCount(); i<s; i++) {

CIMProperty *cp = new CIMProperty(ci->getProperty(i));

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;

Line 1843

Line 2073

if (str)

cop->setClassName(str);

jEnv->ReleaseStringUTFChars(jCn,str);

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);

Line 1910

Line 2141

const char *str = jEnv->GetStringUTFChars(jName,NULL);

cop->setHost(String(str));

jEnv->ReleaseStringUTFChars(jName,str);

}

Line 1931

Line 2163

const char *str = jEnv->GetStringUTFChars(jName,NULL);

cop->setClassName(String(str));

jEnv->ReleaseStringUTFChars(jName,str);

}

Line 1952

Line 2185

const char *str = jEnv->GetStringUTFChars(jName,NULL);

cop->setNameSpace(CIMNamespaceName(str));

jEnv->ReleaseStringUTFChars(jName,str);

}

Line 1965

Line 2199

keyBindings.append(CIMKeyBinding(str,*cv));

cop->setKeyBindings(Array<CIMKeyBinding>(keyBindings));

jEnv->ReleaseStringUTFChars(jId,str);

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeys

(JNIEnv *jEnv, jobject jThs, jint jCop, jobject jVec)

{

JMPIjvm::cacheIDs(jEnv);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

const Array<CIMKeyBinding> &akb = cop->getKeyBindings();

Line 2003

Line 2240

cp=new CIMProperty(n,*cv, 0, ((CIMObjectPath) akb[i].getValue()).getClassName());

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;

Line 2019

Line 2256

const char *strKeyName = jEnv->GetStringUTFChars(jStr,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();

if (n==String(strKeyName)) {

if (n==String(strKeyName))

{

retStr=jEnv->NewStringUTF(akb[i].getValue().getCString());

break;

}

Line 2039

Line 2279

CIMObjectPath *cop = new CIMObjectPath();

cop->set(String(strCop));

jEnv->ReleaseStringUTFChars(jStr,strCop);

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);

Line 2047

Line 2288

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setKeys

(JNIEnv *jEnv, jobject jThs, jint jCop, jobject jVec)

{

JMPIjvm::cacheIDs(jEnv);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

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);

akb.append(CIMKeyBinding(cp->getName(),cp->getValue()));

Line 2182

Line 2425

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);

}

CIMType toPtype (int jType)

{

if (jType > 13)

return (CIMType)14;

return

(CIMType)(jTypeToPType[jType]);

}

Line 2261

Line 2517

String n(str);

cp->setParameterName(n);

jEnv->ReleaseStringUTFChars(jN,str);

}

Line 2307

Line 2564

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1property

(JNIEnv *jEnv, jobject jThs, jstring jN, jint jV)

{

try {

CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);

const char *str = jEnv->GetStringUTFChars(jN,NULL);

CIMProperty *cp = 0;

jint jCp = -1;

try {

if (cv->getType()!=CIMTYPE_REFERENCE)

{

cp=new CIMProperty(String(str),*cv);

else {

}

if (!cv->isArray()) {

else

{

if (!cv->isArray())

{

CIMObjectPath cop;

cv->get(cop);

cp=new CIMProperty(String(str),*cv,0, cop.getClassName());

}

else {

else

{

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);

return -1;

jEnv->ReleaseStringUTFChars(jN,str);

return jCp;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setValue

Line 2511

Line 2775

const char *str = jEnv->GetStringUTFChars(jN,NULL);

cp->setName(CIMName(str));

jEnv->ReleaseStringUTFChars(jN,str);

}

Line 2623

Line 2888

(JNIEnv *jEnv, jobject jThs, jint jQ, jstring jN)

{

CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ);

CIMQualifierDecl *nqt;

const char *str = jEnv->GetStringUTFChars(jN,NULL);

jint jret = 0;

nqt=qt;

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

{

qt->setName(CIMName(str));

CIMQualifierDecl *nqt = new CIMQualifierDecl(*qt);

jret = DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, nqt);

}

jEnv->ReleaseStringUTFChars(jN,str);

return DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, nqt);

return jret;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setValue

Line 2716

Line 2991

dt=new CIMDateTime();

else

dt=new CIMDateTime(String(str));

jEnv->ReleaseStringUTFChars(jN,str);

return DEBUG_ConvertCToJava (CIMDateTime*, jint, dt);

Line 2759

Line 3035

{

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

Line 2992

Line 3268

(JNIEnv *jEnv, jobject jThs, jobjectArray jstringA)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength(jstringA);

Array<String> strA;

for (jsize i=0;i<len;i++) {

jstring jsA=(jstring)jEnv->GetObjectArrayElement(jstringA,i);

const char *str=jEnv->GetStringUTFChars(jsA,NULL);

strA.append(String(str));

jEnv->ReleaseStringUTFChars(jsA,str);

}

Line 3059

Line 3336

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())

Line 3071

Line 3350

case CIMTYPE_BOOLEAN:

Boolean bo;

cv->get(bo);

return jEnv->NewObject(classRefs[1],instanceMethodIDs[1],bo);

return jEnv->NewObject(JMPIjvm::jv.BooleanClassRef,JMPIjvm::jv.BooleanNewZ,bo);

break;

case CIMTYPE_SINT8:

Sint8 s8;

cv->get(s8);

return jEnv->NewObject(classRefs[2],instanceMethodIDs[2],s8);

return jEnv->NewObject(JMPIjvm::jv.ByteClassRef,JMPIjvm::jv.ByteNewB,s8);

break;

case CIMTYPE_UINT8:

Uint8 u8;

cv->get(u8);

return jEnv->NewObject(classRefs[8],instanceMethodIDs[8],u8);

return jEnv->NewObject(JMPIjvm::jv.UnsignedInt8ClassRef,JMPIjvm::jv.UnsignedInt8NewS,u8);

break;

case CIMTYPE_SINT16:

Sint16 s16;

cv->get(s16);

return jEnv->NewObject(classRefs[3],instanceMethodIDs[3],s16);

return jEnv->NewObject(JMPIjvm::jv.ShortClassRef,JMPIjvm::jv.ShortNewS,s16);

break;

case CIMTYPE_UINT16:

Uint16 u16;

cv->get(u16);

return jEnv->NewObject(classRefs[9],instanceMethodIDs[9],u16);

return jEnv->NewObject(JMPIjvm::jv.UnsignedInt16ClassRef,JMPIjvm::jv.UnsignedInt16NewI,u16);

break;

case CIMTYPE_SINT32:

Sint32 s32;

cv->get(s32);

return jEnv->NewObject(classRefs[4],instanceMethodIDs[4],s32);

return jEnv->NewObject(JMPIjvm::jv.IntegerClassRef,JMPIjvm::jv.IntegerNewI,s32);

break;

case CIMTYPE_UINT32:

Uint32 u32;

cv->get(u32);

return jEnv->NewObject(classRefs[10],instanceMethodIDs[10],u32);

return jEnv->NewObject(JMPIjvm::jv.UnsignedInt32ClassRef,JMPIjvm::jv.UnsignedInt32NewJ,u32);

break;

case CIMTYPE_SINT64:

Sint64 s64;

cv->get(s64);

return jEnv->NewObject(classRefs[5],instanceMethodIDs[5],s64);

return jEnv->NewObject(JMPIjvm::jv.LongClassRef,JMPIjvm::jv.LongNewJ,s64);

break;

case CIMTYPE_UINT64: {

Uint64 u64;

cv->get(u64);

jobject big=jEnv->CallStaticObjectMethod(classRefs[14],staticMethodIDs[0],u64);

jobject big=jEnv->CallStaticObjectMethod(JMPIjvm::jv.BigIntegerClassRef,JMPIjvm::jv.BigIntegerValueOf,u64);

return jEnv->NewObject(classRefs[11],instanceMethodIDs[11],big);

return jEnv->NewObject(JMPIjvm::jv.UnsignedInt64ClassRef,JMPIjvm::jv.UnsignedInt64NewBi,big);

}

break;

case CIMTYPE_REAL32:

float f;

cv->get(f);

return jEnv->NewObject(classRefs[6],instanceMethodIDs[6],f);

return jEnv->NewObject(JMPIjvm::jv.FloatClassRef,JMPIjvm::jv.FloatNewF,f);

break;

case CIMTYPE_REAL64:

double d;

cv->get(d);

return jEnv->NewObject(classRefs[7],instanceMethodIDs[7],d);

return jEnv->NewObject(JMPIjvm::jv.DoubleClassRef,JMPIjvm::jv.DoubleNewD,d);

break;

case CIMTYPE_STRING: {

String s;

Line 3137

Line 3416

CIMObjectPath ref;

cv->get(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:

Line 3147

Line 3426

CIMDateTime dt;

cv->get(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:

Line 3163

Line 3442

Array<Boolean> bo;

cv->get(bo);

int s=bo.size();

jobjectArray jbooleanA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[1],0);

jobjectArray jbooleanA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.BooleanClassRef,0);

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jbooleanA, i,

jEnv->NewObject(classRefs[1],instanceMethodIDs[1],bo[i]));

jEnv->NewObject(JMPIjvm::jv.BooleanClassRef,JMPIjvm::jv.BooleanNewZ,bo[i]));

return jbooleanA;

}

break;

Line 3173

Line 3452

Array<Sint8> s8;

cv->get(s8);

int s=s8.size();

jobjectArray jbyteA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[2],0);

jobjectArray jbyteA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.ByteClassRef,0);

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jbyteA, i,

jEnv->NewObject(classRefs[2],instanceMethodIDs[2],s8[i]));

jEnv->NewObject(JMPIjvm::jv.ByteClassRef,JMPIjvm::jv.ByteNewB,s8[i]));

return jbyteA;

}

break;

Line 3183

Line 3462

Array<Uint8> u8;

cv->get(u8);

int s=u8.size();

jobjectArray jshortA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[8],0);

jobjectArray jshortA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.UnsignedInt8ClassRef,0);

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jshortA, i,

jEnv->NewObject(classRefs[8],instanceMethodIDs[8],u8[i]));

jEnv->NewObject(JMPIjvm::jv.UnsignedInt8ClassRef,JMPIjvm::jv.UnsignedInt8NewS,u8[i]));

return jshortA;

}

break;

Line 3193

Line 3472

Array<Sint16> s16;

cv->get(s16);

int s=s16.size();

jobjectArray jshortA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[3],0);

jobjectArray jshortA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.ShortClassRef,0);

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jshortA, i,

jEnv->NewObject(classRefs[3],instanceMethodIDs[3],s16[i]));

jEnv->NewObject(JMPIjvm::jv.ShortClassRef,JMPIjvm::jv.ShortNewS,s16[i]));

return jshortA;

}

break;

Line 3203

Line 3482

Array<Uint16> u16;

cv->get(u16);

int s=u16.size();

jobjectArray jintA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[9],0);

jobjectArray jintA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.UnsignedInt16ClassRef,0);

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jintA, i,

jEnv->NewObject(classRefs[9],instanceMethodIDs[9],u16[i]));

jEnv->NewObject(JMPIjvm::jv.UnsignedInt16ClassRef,JMPIjvm::jv.UnsignedInt16NewI,u16[i]));

return jintA;

}

break;

Line 3213

Line 3492

Array<Sint32> s32;

cv->get(s32);

int s=s32.size();

jobjectArray jintA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[4],0);

jobjectArray jintA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.IntegerClassRef,0);

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jintA, i,

jEnv->NewObject(classRefs[4],instanceMethodIDs[4],s32[i]));

jEnv->NewObject(JMPIjvm::jv.IntegerClassRef,JMPIjvm::jv.IntegerNewI,s32[i]));

return jintA;

}

break;

Line 3223

Line 3502

Array<Uint32> u32;

cv->get(u32);

int s=u32.size();

jobjectArray jlongA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[10],0);

jobjectArray jlongA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.UnsignedInt32ClassRef,0);

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jlongA, i,

jEnv->NewObject(classRefs[10],instanceMethodIDs[10],u32[i]));

jEnv->NewObject(JMPIjvm::jv.UnsignedInt32ClassRef,JMPIjvm::jv.UnsignedInt32NewJ,u32[i]));

return jlongA;

}

break;

Line 3233

Line 3512

Array<Sint64> s64;

cv->get(s64);

int s=s64.size();

jobjectArray jlongA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[5],0);

jobjectArray jlongA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.LongClassRef,0);

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jlongA, i,

jEnv->NewObject(classRefs[5],instanceMethodIDs[5],s64[i]));

jEnv->NewObject(JMPIjvm::jv.LongClassRef,JMPIjvm::jv.LongNewJ,s64[i]));

return jlongA;

}

break;

Line 3246

Line 3525

Array<Real32> r32;

cv->get(r32);

int s=r32.size();

jobjectArray jfloatA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[6],0);

jobjectArray jfloatA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.FloatClassRef,0);

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jfloatA, i,

jEnv->NewObject(classRefs[6],instanceMethodIDs[6],r32[i]));

jEnv->NewObject(JMPIjvm::jv.FloatClassRef,JMPIjvm::jv.FloatNewF,r32[i]));

return jfloatA;

}

break;

Line 3256

Line 3535

Array<Real64> r64;

cv->get(r64);

int s=r64.size();

jobjectArray jdoubleA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[7],0);

jobjectArray jdoubleA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.DoubleClassRef,0);

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jdoubleA, i,

jEnv->NewObject(classRefs[7],instanceMethodIDs[7],r64[i]));

jEnv->NewObject(JMPIjvm::jv.DoubleClassRef,JMPIjvm::jv.DoubleNewD,r64[i]));

return jdoubleA;

}

break;

Line 3266

Line 3545

Array<String> str;

cv->get(str);

int s=str.size();

jobjectArray jstringA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[22],0);

jobjectArray jstringA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.StringClassRef,0);

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jstringA, i,

jEnv->NewStringUTF(str[i].getCString()));

return jstringA;

Line 3335

Line 3614

}

Sint32 p=hostName_.reverseFind(':');

if (p>=0) {

if (isdigit(hostName_[p+1]))

if ((hostName_[p+1] >= '0') && (hostName_[p+1] <= '9'))

port_=atoi(hostName_.subString(p+1).getCString());

hostName_.remove(p);

}

Line 3410

Line 3689

cNs->port_=0;

cNs->hostName_=str;

jEnv->ReleaseStringUTFChars(jHn,str);

}

Line 3420

Line 3700

const char *str = jEnv->GetStringUTFChars(jN,NULL);

cNs->nameSpace_=str;

jEnv->ReleaseStringUTFChars(jN,str);

}

Line 3512

Line 3793

void checkNs(CIMObjectPath *cop, jint jNs) {

if (cop->getNameSpace().isNull()) {

_nameSpace *ns=(_nameSpace*)jNs;

_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);

cop->setNameSpace(CIMNamespaceName(ns->nameSpace()));

cop->setNameSpace(CIMNamespaceName(cNs->nameSpace()));

}

Line 3521

Line 3803

(JNIEnv *jEnv, jobject jThs, jint jNs, jstring jUn, jstring jPw)

{

_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);

const char *un=jEnv->GetStringUTFChars(jUn,NULL);

const char *pw=jEnv->GetStringUTFChars(jPw,NULL);

jint jCc = 0;

try {

JMPIjvm::cacheIDs(jEnv);

CIMClient *cc=new CIMClient();

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);

return 0;

jEnv->ReleaseStringUTFChars(jUn,un);

jEnv->ReleaseStringUTFChars(jPw,pw);

return jCc;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1disconnect

Line 3653

Line 3938

try {

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));

}

Catch(jEnv);

Line 3672

Line 3958

try {

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));

}

Catch(jEnv);

Line 3810

Line 4102

Catch(jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn)

{

Line 3818

Line 4109

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

const char *str = jEnv->GetStringUTFChars(jPn,NULL);

CIMName pName(str);

jint jCv = 0;

jEnv->ReleaseStringUTFChars(jPn,str);

try {

checkNs(cop,jNs);

CIMValue *val=new CIMValue(cCc->getProperty(cop->getNameSpace(),*cop,pName));

return DEBUG_ConvertCToJava (CIMValue*, jint, val);

jCv = DEBUG_ConvertCToJava (CIMValue*, jint, val);

}

Catch(jEnv);

return 0;

jEnv->ReleaseStringUTFChars(jPn,str);

return jCv;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty

Line 3839

Line 4134

const char *str = jEnv->GetStringUTFChars(jPn,NULL);

CIMName pName(str);

jEnv->ReleaseStringUTFChars(jPn,str);

try {

checkNs(cop,jNs);

cCc->setProperty(cop->getNameSpace(),*cop,pName,*val);

}

Catch(jEnv);

jEnv->ReleaseStringUTFChars(jPn,str);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn, jobject jIn, jobject jOut)

{

JMPIjvm::cacheIDs(jEnv);

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

const char *str = jEnv->GetStringUTFChars(jMn,NULL);

CIMName method(str);

jint jCv = 0;

jEnv->ReleaseStringUTFChars(jMn,str);

Array<CIMParamValue> in;

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);

jobject jProp=jEnv->CallObjectMethod(jIn,instanceMethodIDs[16],i);

jobject jProp=jEnv->CallObjectMethod(jIn,JMPIjvm::jv.VectorElementAt,i);

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);

JMPIjvm::checkException(jEnv);

in.append(CIMParamValue(p->getName().getString(),p->getValue()));

}

try {

checkNs(cop,jNs);

CIMValue *val=new CIMValue(cCc->invokeMethod(cop->getNameSpace(),*cop,method,in,out));

for (int i=0,m=out.size(); i<m; i++) {

Line 3882

Line 4180

const CIMValue v = parm.getValue();

CIMProperty *p = new CIMProperty(parm.getParameterName(),v,v.getArraySize());

jint jp = DEBUG_ConvertCToJava (CIMProperty*, jint, p);

jobject prop = jEnv->NewObject(JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jp);

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);

return 0;

jEnv->ReleaseStringUTFChars(jMn,str);

return jCv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod24

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn,

jobjectArray jIn, jobjectArray jOut)

{

JMPIjvm::cacheIDs(jEnv);

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

const char *str = jEnv->GetStringUTFChars(jMn,NULL);

CIMName method(str);

jint jCv = 0;

jEnv->ReleaseStringUTFChars(jMn,str);

Array<CIMParamValue> in;

Array<CIMParamValue> out;

Line 3914

Line 4214

jobject jArg=jEnv->GetObjectArrayElement(jIn,i);

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);

JMPIjvm::checkException(jEnv);

Line 3926

Line 4226

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++) {

const CIMParamValue &parm = out[i];

CIMParamValue *parm = new CIMParamValue (out[i]);

jint jParm = DEBUG_ConvertCToJava (const CIMParamValue*, jint, &parm);

jint jParm = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);

jEnv->SetObjectArrayElement(jOut,i,

jEnv->NewObject(classRefs[29],instanceMethodIDs[40],jParm));

jEnv->SetObjectArrayElement(jOut,

jEnv->NewObject(JMPIjvm::jv.CIMArgumentClassRef,JMPIjvm::jv.CIMArgumentNewI,jParm));

}

return DEBUG_ConvertCToJava (CIMValue*, jint, val);

jCv = DEBUG_ConvertCToJava (CIMValue*, jint, val);

}

Catch(jEnv);

return 0;

jEnv->ReleaseStringUTFChars(jMn,str);

return jCv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery

Line 3946

Line 4250

const char *str = jEnv->GetStringUTFChars(jQuery,NULL);

String query(str);

/* Note:

/* @NOTE

** 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));

** What does work is:

** 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);

str=jEnv->GetStringUTFChars(jQl,NULL);

String ql(str);

jEnv->ReleaseStringUTFChars(jQl,str);

Line 4159

Line 4481

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateNameSpaces

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jboolean deep, jobject jVec)

{

JMPIjvm::cacheIDs(jEnv);

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

String ns = cop->getNameSpace().getString();

Line 4174

Line 4498

continue;

String x=ns+"/"+n;

jstring str=jEnv->NewStringUTF(x.getCString());

jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],str);

jEnv->CallVoidMethod(jVec,JMPIjvm::jv.VectorAddElement,str);

}

Catch(jEnv);

Line 4207

Line 4531

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);

}

} // extern "C"

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.22
changed lines
	Added in v.1.33

No CVS admin address has been configured