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.60 and 1.83

version 1.60, 2006/10/31 19:02:34

version 1.83, 2008/08/29 09:22:34

Line 33

#include "JMPIImpl.h"

#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)

#if defined(PEGASUS_OS_TYPE_WINDOWS)

#include <Pegasus/Common/DynamicLibrary.h>

#else

#include <dlfcn.h>

Line 48

#include <Pegasus/Common/CIMObjectPath.h>

#include <Pegasus/Common/CIMProperty.h>

#include <Pegasus/Common/OperationContext.h>

#include <Pegasus/Common/Tracer.h>

#include <Pegasus/Provider/CIMOMHandle.h>

#include <Pegasus/Client/CIMClient.h>

#include <Pegasus/ProviderManager2/JMPI/JMPIProviderManager.h>

Line 60

Line 61

JavaVM *JMPIjvm::jvm=NULL;

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"

Line 109

Line 103

/*32*/ "java/lang/Character",

/*33*/ "org/pegasus/jmpi/OperationContext",

/*34*/ "java/lang/Class",

/*35*/ "java/io/ByteArrayOutputStream",

/*36*/ "java/io/PrintStream"

};

const METHOD_STRUCT instanceMethodNames[]={

/*00 VectorNew */ { /*Vector */ 0, "<init>", "()V" },

/*00 VectorNew */

/*01 BooleanNewZ */ { /*Boolean */ 1, "<init>", "(Z)V" },

{ /*Vector */

/*02 ByteNewB */ { /*Byte */ 2, "<init>", "(B)V" },

/*03 ShortNewS */ { /*Short */ 3, "<init>", "(S)V" },

"<init>",

/*04 IntegerNewI */ { /*Integer */ 4, "<init>", "(I)V" },

"()V" },

/*05 LongNewJ */ { /*Long */ 5, "<init>", "(J)V" },

/*01 BooleanNewZ */

/*06 FloatNewF */ { /*Float */ 6, "<init>", "(F)V" },

{ /*Boolean */

/*07 DoubleNewD */ { /*Double */ 7, "<init>", "(D)V" },

/*08 UnsignedInt8NewS */ { /*UnsignedInt8 */ 8, "<init>", "(S)V" },

"<init>",

/*09 UnsignedInt16NewI */ { /*UnsignedInt16 */ 9, "<init>", "(I)V" },

"(Z)V" },

/*10 UnsignedInt32NewJ */ { /*UnsignedInt32 */10, "<init>", "(J)V" },

/*02 ByteNewB */

/*11 UnsignedInt64NewBi */ { /*UnsignedInt64 */11, "<init>", "(Ljava/math/BigInteger;)V" },

{ /*Byte */

/*12 CIMObjectPathNewI */ { /*CIMObjectPath */12, "<init>", "(I)V" },

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

"<init>",

/*14 CIMPropertyNewI */ { /*CIMProperty */15, "<init>", "(I)V" },

"(B)V" },

/*15 VectorAddElement */ { /*Vector */ 0, "addElement", "(Ljava/lang/Object;)V" },

/*03 ShortNewS */

/*16 VectorElementAt */ { /*Vector */ 0, "elementAt", "(I)Ljava/lang/Object;" },

{ /*Short */

/*17 CIMOMHandleNewISt */ { /*CIMOMHandle */16, "<init>", "(ILjava/lang/String;)V" },

/*18 CIMExceptionNewI */ { /*CIMException */13, "<init>", "(I)V" },

"<init>",

/*19 CIMClassNewI */ { /*CIMClass */17, "<init>", "(I)V" },

"(S)V" },

/*20 CIMInstanceNewI */ { /*CIMInstance */18, "<init>", "(I)V" },

/*04 IntegerNewI */

/*21 CIMObjectPathCInst */ { /*CIMObjectPath */12, "cInst", "()I" },

{ /*Integer */

/*22 CIMInstanceCInst */ { /*CIMInstance */18, "cInst", "()I" },

/*23 CIMClassCInst */ { /*CIMClass */17, "cInst", "()I" },

"<init>",

/*24 ObjectToString */ { /*Object */20, "toString", "()Ljava/lang/String;" },

"(I)V" },

/*25 ThrowableGetMessage */ { /*Throwable */21, "getMessage", "()Ljava/lang/String;" },

/*05 LongNewJ */

/*26 CIMExceptionGetID */ { /*CIMException */13, "getID", "()Ljava/lang/String;" },

{ /*Long */

/*27 VectorSize */ { /*Vector */ 0, "size", "()I" },

/*28 CIMPropertyCInst */ { /*CIMProperty */15, "cInst", "()I" },

"<init>",

/*29 CIMOMHandleGetClass */ { /*CIMOMHandle */16, "getClass", "(Lorg/pegasus/jmpi/CIMObjectPath;Z)Lorg/pegasus/jmpi/CIMClass;" },

"(J)V" },

/*30 VectorRemoveElementAt */ { /*Vector */ 0, "removeElementAt", "(I)V" },

/*06 FloatNewF */

/*31 CIMValueCInst */ { /*CIMValue */19, "cInst", "()I" },

{ /*Float */

/*32 CIMExceptionNewISt */ { /*CIMException */13, "<init>", "(ILjava/lang/String;)V" },

/*33 CIMExceptionGetCode */ { /*CIMException */13, "getCode", "()I" },

"<init>",

/*34 CIMDateTimeNewI */ { /*CIMDateTime */24, "<init>", "(I)V" },

"(F)V" },

/*35 SelectExpNewI */ { /*SelectExp */25, "<init>", "(I)V" },

/*07 DoubleNewD */

/*36 CIMQualifierNewI */ { /*CIMQualifier */26, "<init>", "(I)V" },

{ /*Double */

/*37 CIMFlavorNewI */ { /*CIMFlavor */28, "<init>", "(I)V" },

/*38 CIMFlavorGetFlavor */ { /*CIMFlavor */28, "getFlavor", "()I" },

"<init>",

/*39 CIMArgumentCInst */ { /*CIMArgument */29, "cInst", "()I" },

"(D)V" },

/*40 CIMArgumentNewI */ { /*CIMArgument */29, "<init>", "(I)V" },

/*08 UnsignedInt8NewS */

/*41 CIMExceptionNew */ { /*CIMException */13, "<init>", "()V" },

{ /*UnsignedInt8 */

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

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

"<init>",

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

"(S)V" },

/*45 CIMValueNewI */ { /*CIMValue */19, "<init>", "(I)V" },

/*09 UnsignedInt16NewI */

/*46 CIMObjectNewIZ */ { /*CIMObject */31, "<init>", "(IZ)V" },

{ /*UnsignedInt16 */

/*47 CharacterNewC */ { /*Character */32, "<init>", "(C)V" },

/*48 OperationContextNewI */ { /*OperationContext */33, "<init>", "(I)V" },

"<init>",

/*49 OperationContextUnassociate */ { /*OperationContext */33, "unassociate", "()V" },

"(I)V" },

/*50 ClassGetInterfaces */ { /*Class */34, "getInterfaces", "()[Ljava/lang/Class;" },

/*10 UnsignedInt32NewJ */

/*51 ClassGetName */ { /*Class */34, "getName", "()Ljava/lang/String;" },

{ /*UnsignedInt32 */

/*52 UnsignedInt64NewStr */ { /*UnsignedInt64 */11, "<init>", "(Ljava/lang/String;)V" }

10,

"<init>",

"(J)V" },

/*11 UnsignedInt64NewBi */

{ /*UnsignedInt64 */

11,

"<init>",

"(Ljava/math/BigInteger;)V" },

/*12 CIMObjectPathNewJ */

{ /*CIMObjectPath */

12,

"<init>",

"(J)V" },

/*13 CIMExceptionNewSt */

{ /*CIMException */

13,

"<init>",

"(Ljava/lang/String;)V" },

/*14 CIMPropertyNewJ */

{ /*CIMProperty */

15,

"<init>",

"(J)V" },

/*15 VectorAddElement */

{ /*Vector */

"addElement",

"(Ljava/lang/Object;)V" },

/*16 VectorElementAt */

{ /*Vector */

"elementAt",

"(I)Ljava/lang/Object;" },

/*17 CIMOMHandleNewJSt */

{ /*CIMOMHandle */

16,

"<init>",

"(JLjava/lang/String;)V" },

/*18 CIMExceptionNewI */

{ /*CIMException */

13,

"<init>",

"(I)V" },

/*19 CIMClassNewJ */

{ /*CIMClass */

17,

"<init>",

"(J)V" },

/*20 CIMInstanceNewJ */

{ /*CIMInstance */

18,

"<init>",

"(J)V" },

/*21 CIMObjectPathCInst */

{ /*CIMObjectPath */

12,

"cInst",

"()J" },

/*22 CIMInstanceCInst */

{ /*CIMInstance */

18,

"cInst",

"()J" },

/*23 CIMClassCInst */

{ /*CIMClass */

17,

"cInst",

"()J" },

/*24 ObjectToString */

{ /*Object */

20,

"toString",

"()Ljava/lang/String;" },

/*25 ThrowableGetMessage */

{ /*Throwable */

21,

"getMessage",

"()Ljava/lang/String;" },

/*26 CIMExceptionGetID */

{ /*CIMException */

13,

"getID",

"()Ljava/lang/String;" },

/*27 VectorSize */

{ /*Vector */

"size",

"()I" },

/*28 CIMPropertyCInst */

{ /*CIMProperty */

15,

"cInst",

"()J" },

/*29 CIMOMHandleGetClass */

{ /*CIMOMHandle */

16,

"getClass",

"(Lorg/pegasus/jmpi/CIMObjectPath;Z)Lorg/pegasus/jmpi/CIMClass;" },

/*30 VectorRemoveElementAt */

{ /*Vector */

"removeElementAt",

"(I)V" },

/*31 CIMValueCInst */

{ /*CIMValue */

19,

"cInst",

"()J" },

/*32 CIMExceptionNewISt */

{ /*CIMException */

13,

"<init>",

"(ILjava/lang/String;)V" },

/*33 CIMExceptionGetCode */

{ /*CIMException */

13,

"getCode",

"()I" },

/*34 CIMDateTimeNewJ */

{ /*CIMDateTime */

24,

"<init>",

"(J)V" },

/*35 SelectExpNewJ */

{ /*SelectExp */

25,

"<init>",

"(J)V" },

/*36 CIMQualifierNewJ */

{ /*CIMQualifier */

26,

"<init>",

"(J)V" },

/*37 CIMFlavorNewI */

{ /*CIMFlavor */

28,

"<init>",

"(I)V" },

/*38 CIMFlavorGetFlavor */

{ /*CIMFlavor */

28,

"getFlavor",

"()I" },

/*39 CIMArgumentCInst */

{ /*CIMArgument */

29,

"cInst",

"()J" },

/*40 CIMArgumentNewJ */

{ /*CIMArgument */

29,

"<init>",

"(J)V" },

/*41 CIMExceptionNew */

{ /*CIMException */

13,

"<init>",

"()V" },

/*42 CIMExceptionNewStOb */

{ /*CIMException */

13,

"<init>",

"(Ljava/lang/String;Ljava/lang/Object;)V" },

/*43 CIMExceptionNewStObOb */

{ /*CIMException */

13,

"<init>",

"(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)V" },

/*44 CIMExceptionNewStObObOb */

{ /*CIMException */

13,

"<init>",

"(Ljava/lang/String;Ljava/lang/Object;"

"Ljava/lang/Object;Ljava/lang/Object;)V" },

/*45 CIMValueNewJ */

{ /*CIMValue */

19,

"<init>",

"(J)V" },

/*46 CIMObjectNewJZ */

{ /*CIMObject */

31,

"<init>",

"(JZ)V" },

/*47 CharacterNewC */

{ /*Character */

32,

"<init>",

"(C)V" },

/*48 OperationContextNewJ */

{ /*OperationContext */

33,

"<init>",

"(J)V" },

/*49 OperationContextUnassociate */

{ /*OperationContext */

33,

"unassociate",

"()V" },

/*50 ClassGetInterfaces */

{ /*Class */

34,

"getInterfaces",

"()[Ljava/lang/Class;" },

/*51 ClassGetName */

{ /*Class */

34,

"getName",

"()Ljava/lang/String;" },

/*52 UnsignedInt64NewStr */

{ /*UnsignedInt64 */

11,

"<init>",

"(Ljava/lang/String;)V" },

/*53 ByteArrayOutputStreamNew */

{ /*ByteArrayOutputStream */

35,

"<init>",

"()V" },

/*54 PrintStreamNewOb */

{ /*PrintStreamNew */

36,

"<init>",

"(Ljava/io/OutputStream;)V" },

/*55 ThrowablePrintStackTrace */

{ /*Throwable */

21,

"printStackTrace",

"(Ljava/io/PrintStream;)V" },

/*56 ByteArrayOutputStreamToString */

{ /*ByteArrayOutputStream */

35,

"toString",

"()Ljava/lang/String;" }

};

const METHOD_STRUCT staticMethodNames[]={

/*00*/ { 14, "valueOf", "(J)Ljava/math/BigInteger;" },

/*00*/ { 14,

/*01*/ { 23, "load", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Class;" },

"valueOf",

"(J)Ljava/math/BigInteger;" },

/*01*/ { 23,

"load",

"(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Class;" },

};

static int methodInitDone=0;

jclass classRefs[sizeof(classNames)/sizeof(classNames[0])];

jmethodID instanceMethodIDs[sizeof(instanceMethodNames)/sizeof(instanceMethodNames[0])];

jmethodID instanceMethodIDs[sizeof(instanceMethodNames) /

jmethodID staticMethodIDs[sizeof(staticMethodNames)/sizeof(staticMethodNames[0])];

sizeof(instanceMethodNames[0])];

jmethodID staticMethodIDs[sizeof(staticMethodNames) /

sizeof(staticMethodNames[0])];

jclass JMPIjvm::getGlobalClassRef(JNIEnv *env, const char* name)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIjvm::getGlobalClassRef");

jclass localRefCls = env->FindClass(name);

if (localRefCls == NULL)

{

PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"No local Class reference found. (localRefCls==NULL)");

PEG_METHOD_EXIT();

return JNI_FALSE;

}

jclass globalRefCls = (jclass) env->NewGlobalRef(localRefCls);

#if 0

jmethodID jmidToString = env->GetMethodID(globalRefCls, "toString", "()Ljava/lang/String;");

jmethodID jmidToString = env->GetMethodID(globalRefCls,

jstring jstringResult = (jstring)env->CallObjectMethod(globalRefCls, jmidToString);

"toString",

"()Ljava/lang/String;");

jstring jstringResult = (jstring)env->CallObjectMethod(globalRefCls,

jmidToString);

const char *pszResult = env->GetStringUTFChars(jstringResult, 0);

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

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"globalRefCls = %p, name = %s, pszResult = %s",

globalRefCls,name,pszResult));

env->ReleaseStringUTFChars (jstringResult, pszResult);

#else

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

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"globalRefCls = %p, name = %s",globalRefCls,name));

#endif

env->DeleteLocalRef(localRefCls);

PEG_METHOD_EXIT();

return globalRefCls;

}

Line 215

Line 467

int JMPIjvm::cacheIDs(JNIEnv *env)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIjvm::cacheIDs");

if (methodInitDone == 1)

{

PEG_METHOD_EXIT();

return JNI_TRUE;

}

if (methodInitDone == -1)

{

PEG_METHOD_EXIT();

return JNI_FALSE;

}

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): enter"<<PEGASUS_STD(endl));

methodInitDone = -1;

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)

{

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error: Count not find global class ref for "<<classNames[i]<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Error: Count not find global class ref for %s",classNames[i]));

PEG_METHOD_EXIT();

return JNI_FALSE;

}

for (unsigned j = 0; j<(sizeof(instanceMethodNames)/sizeof(instanceMethodNames[0])); j++)

unsigned instanceMethodNamesSize =

sizeof(instanceMethodNames)/sizeof(instanceMethodNames[0]);

for (unsigned j = 0; j<instanceMethodNamesSize; j++)

{

//////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<j<<": "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<": "<<instanceMethodNames[j].signature<<PEGASUS_STD(endl));

instanceMethodIDs[j] = env->GetMethodID(

if ((instanceMethodIDs[j] = env->GetMethodID(classRefs[instanceMethodNames[j].clsIndex],

classRefs[instanceMethodNames[j].clsIndex],

instanceMethodNames[j].methodName,

instanceMethodNames[j].signature)) == NULL)

instanceMethodNames[j].signature);

if (instanceMethodIDs[j] == NULL)

{

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error could not get method id for "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Error: Could not get instance method id for %s:%s",

classNames[instanceMethodNames[j].clsIndex],

instanceMethodNames[j].methodName));

PEG_METHOD_EXIT();

return 0;

}

unsigned staticMethodNamesSize =

for (unsigned k = 0; k<(sizeof(staticMethodNames)/sizeof(staticMethodNames[0])); k++)

sizeof(staticMethodNames) / sizeof(staticMethodNames[0]);

for (unsigned k = 0; k<staticMethodNamesSize; k++)

{

//////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<k<<": "<<classNames[staticMethodNames[k].clsIndex]<<": "<<staticMethodNames[k].methodName<<": "<<staticMethodNames[k].signature<<PEGASUS_STD(endl));

staticMethodIDs[k] = env->GetStaticMethodID(

if ((staticMethodIDs[k] = env->GetStaticMethodID(classRefs[staticMethodNames[k].clsIndex],

classRefs[staticMethodNames[k].clsIndex],

staticMethodNames[k].methodName,

staticMethodNames[k].signature)) == NULL)

staticMethodNames[k].signature);

if (staticMethodIDs[k] == NULL)

{

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error could not get method id for "<<classNames[staticMethodNames[k].clsIndex]<<": "<<staticMethodNames[k].methodName<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Error: Could not get static method id for %s:%s",

classNames[staticMethodNames[k].clsIndex],

staticMethodNames[k].methodName));

PEG_METHOD_EXIT();

return 0;

}

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): exit"<<PEGASUS_STD(endl));

jv.env = env;

jv.classRefs = classRefs;

jv.instMethodIDs = instanceMethodIDs;

Line 269

Line 544

methodInitDone = 1;

PEG_METHOD_EXIT();

return JNI_TRUE;

}

Line 281

Line 557

int JMPIjvm::destroyJVM()

{

DDD(PEGASUS_STD(cerr)<<"--- JPIjvm::destroyJVM()"<<PEGASUS_STD(endl));

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JPIjvm::destroyJVM");

#ifdef JAVA_DESTROY_VM_WORKS

if (jvm!= NULL)

Line 294

Line 570

jvm = NULL;

PEG_METHOD_EXIT();

return 0;

}

#endif

PEG_METHOD_EXIT();

return -1;

}

Line 305

Line 583

int JMPIjvm::initJVM ()

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JPIjvm::initJVM");

AutoMutex lock (_initMutex);

if (jvm != NULL)

Line 333

Line 613

};

std::ostringstream oss;

#ifdef PEGASUS_DEBUG

PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

if (getenv("PEGASUS_JMPI_TRACE"))

"Start to initialize the JVM.");

JMPIjvm::trace = 1;

else

JMPIjvm::trace = 0;

#else

JMPIjvm::trace = 0;

#endif

DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM()" << PEGASUS_STD(endl));

jv.initRc = 0;

Line 351

Line 623

{

jv.initRc = 1;

DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): No CLASSPATH environment variable found" << PEGASUS_STD(endl));

PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,

"No CLASSPATH environment variable found.");

PEG_METHOD_EXIT();

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

"ProviderManager2.JMPI.JMPIImpl.GET_CLASSPATH_FAILED.STANDARD",

"Could not get CLASSPATH from environment.")

);

#endif

return -1;

}

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

///maxoption++;

for (Uint32 i = 0; i < (int)(sizeof (aEnvOptions)/sizeof (aEnvOptions[0])); i++)

unsigned int aEnvOptionsSize=sizeof(aEnvOptions)/sizeof(aEnvOptions[0]);

for (Uint32 i = 0; i < aEnvOptionsSize; i++)

{

JVMOPTIONS *pEnvOption = &aEnvOptions[i];

Line 393

Line 659

while (fCommaFound)

{

string stringValue;

string::size_type posComma = stringValues.find (',', posStart);

string::size_type posComma = stringValues.find(',',

posStart);

if (posComma != string::npos)

{

Line 407

Line 674

stringValue = stringValues.substr (posStart, posEnd - posStart + 1);

}

DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): fCommaFound = " << fCommaFound << ", posStart = " << posStart << ", posComma = " << posComma << ", posEnd = " << posEnd << "" << PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,

"fCommaFound = %d, posStart = %d, "

"posComma = %d, posEnd = %d",

fCommaFound,posStart,posComma,posEnd));

maxoption++;

Line 416

Line 686

JNIoptions.append (oss.str ());

DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): " << pEnvOption->pszEnvName << " found! Specifying \"" << oss.str () << "\"" << PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,

"%s found! Specifying \"%s\"",

pEnvOption->pszEnvName, (const char*)oss.str().c_str()));

}

else

Line 428

Line 700

JNIoptions.append (oss.str ());

DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): " << pEnvOption->pszEnvName << " found! Specifying \"" << oss.str () << "\"" << PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"%s found! Specifying \"%s\"",

pEnvOption->pszEnvName, (const char*)oss.str().c_str()));

}

Line 438

Line 713

{

jv.initRc = 1;

DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): Could not allocate " << maxoption << " structures of size " << sizeof (JavaVMOption) << PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"Could not allocate %d structures of size %d.",

maxoption,sizeof (JavaVMOption)));

PEG_METHOD_EXIT();

return -1;

}

Line 447

Line 725

{

poptions[i].optionString = (char *)JNIoptions[i].c_str ();

DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): Setting option " << i << " to \"" << poptions[i].optionString << "\"" << PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,

"Setting option %d to \"%s\".",

i ,poptions[i].optionString));

}

vm_args.version = JNI_VERSION_1_2;

Line 466

Line 746

{

jv.initRc = 1;

DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): Can not create Java VM"<<PEGASUS_STD(endl));

PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3,

"Can not create Java VM !");

PEG_METHOD_EXIT();

return -1;

}

Line 490

Line 772

jvm = NULL;

#endif

PEG_METHOD_EXIT();

return -1;

}

jv.initRc = 1;

jv.jvm = jvm;

PEG_METHOD_EXIT();

return res;

}

Line 530

Line 814

const char *pszProviderName,

jclass *pjClass)

{

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIjvm::getProvider");

jobject jProviderInstance = 0;

jclass jClassLoaded = 0;

jmethodID jId = 0;

jobject jProviderInstanceLocal = 0;

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jarName = "<<jarName<<", className = "<<className<<", pszProviderName = "<<pszProviderName<<", pjClass = "<<PEGASUS_STD(hex)<<(int)pjClass<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"jarName = %s, className = %s, pszProviderName = %s, pjClass = %p",

(const char*)jarName.getCString(),

(const char*)className.getCString(),

pszProviderName,pjClass));

// CASE #1

// className has been loaded previously.

Line 543

Line 833

_objectTable.lookup (className, jProviderInstance);

_classTable.lookup (className, jClassLoaded);

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jProviderInstance = "<<PEGASUS_STD(hex)<<(int)jProviderInstance<<", jClassLoaded = "<<(int)jClassLoaded<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"jProviderInstance = %p, jClassLoaded = %p",

jProviderInstance,jClassLoaded));

if ( jProviderInstance

&& jClassLoaded

Line 553

Line 845

{

*pjClass = jClassLoaded;

}

PEG_METHOD_EXIT();

return jProviderInstance;

}

Line 561

Line 853

// className can be loaded via getGlobalClassRef ().

// Load and return the instance.

// NOTE:

// According to http://java.sun.com/j2se/1.5.0/docs/guide/jni/spec/functions.html

// According to

// http://java.sun.com/j2se/1.5.0/docs/guide/jni/spec/functions.html

// In JDK 1.1, FindClass searched only local classes in CLASSPATH.

jClassLoaded = getGlobalClassRef (env,

(const char*)className.getCString ());

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jClassLoaded = "<<PEGASUS_STD(hex)<<(int)jClassLoaded<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"jClassLoaded = %p",jClassLoaded));

if (env->ExceptionCheck ())

{

Line 596

Line 890

fixedClassName = className;

}

DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::getProvider: fixedClassName = "<<fixedClassName<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"fixedClassName = %s",(const char*)fixedClassName.getCString()));

jJarName = env->NewStringUTF ((const char*)jarName.getCString ());

jClassName = env->NewStringUTF ((const char*)fixedClassName.getCString ());

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jJarName = "<<PEGASUS_STD(hex)<<(int)jJarName<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jClassName = "<<PEGASUS_STD(hex)<<(int)jClassName<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

"jJarName = %p, jClassName = %p",

jJarName,jClassName));

jClassLoadedLocal = (jclass)env->CallStaticObjectMethod (JMPIjvm::jv.JarClassLoaderClassRef,

jClassLoadedLocal = (jclass)env->CallStaticObjectMethod(

JMPIjvm::jv.JarClassLoaderClassRef,

JMPIjvm::jv.JarClassLoaderLoad,

jJarName,

jClassName);

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jClassLoadedLocal = "<<PEGASUS_STD(hex)<<(int)jClassLoadedLocal<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"jClassLoadedLocal = %p",jClassLoadedLocal));

if (env->ExceptionCheck ())

{

DDD (env->ExceptionDescribe ());

env->ExceptionDescribe();

DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<pszProviderName<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,

"Unable to instantiate provider %s: "

"Can not load Java class %s from jar %s.",

pszProviderName,

(const char*)fixedClassName.getCString(),

(const char*)jarName.getCString()));

PEG_METHOD_EXIT();

return 0;

}

jClassLoaded = (jclass)env->NewGlobalRef (jClassLoadedLocal);

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jClassLoaded = "<<PEGASUS_STD(hex)<<(int)jClassLoaded<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"jClassLoaded = %p",jClassLoaded));

env->DeleteLocalRef (jClassLoadedLocal);

}

Line 634

Line 939

if (!jClassLoaded)

{

DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<pszProviderName<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,

"Unable to instantiate provider %s: "

"Can not load Java class.",pszProviderName));

PEG_METHOD_EXIT();

return 0;

}

jId = env->GetMethodID (jClassLoaded,

jId = env->GetMethodID (jClassLoaded,"<init>","()V");

"<init>",

"()V");

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jId = "<<PEGASUS_STD(hex)<<(int)jId<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"GetMethodID() jID = %p ",jId));

jProviderInstanceLocal = env->NewObject (jClassLoaded,

jId);

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jProviderInstanceLocal = "<<PEGASUS_STD(hex)<<(int)jProviderInstanceLocal<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"NewObject() jProviderInstanceLocal = %p ",

jProviderInstanceLocal));

if (!jProviderInstanceLocal)

{

DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<pszProviderName<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,

"Unable to instantiate provider %s: "

"No new Java object of provider.",pszProviderName));

PEG_METHOD_EXIT();

return 0;

}

jProviderInstance = (jobject)env->NewGlobalRef (jProviderInstanceLocal);

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jProviderInstance = "<<PEGASUS_STD(hex)<<(int)jProviderInstance<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"NewGlobalRef() jProviderInstance = %p ",jProviderInstance));

if (!jProviderInstance)

{

DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<pszProviderName<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,

"Unable to instantiate provider %s: "

"No global reference to provider object.",pszProviderName));

PEG_METHOD_EXIT();

return 0;

}

_classTable.insert (className, jClassLoaded);

_objectTable.insert (className, jProviderInstance);

PEG_METHOD_EXIT();

return jProviderInstance;

}

Line 680

Line 994

jobject gProv = NULL;

jclass scls = NULL;

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: cn = "<<cn<<", cls = "<<cls<<PEGASUS_STD(endl));

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIjvm::getProvider");

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"cn = %s, cls = %p",cn,cls));

_objectTable.lookup(cln,gProv);

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

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"gProv = %p, scls = %p",gProv,scls));

if (gProv)

{

Line 695

Line 1014

scls = getGlobalClassRef(env,cn);

if (env->ExceptionCheck())

{

DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::getProvider: Provider "<<cn<<" not found"<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,

DDD(env->ExceptionDescribe());

"Provider %s not found: No global reference.",cn));

PEG_METHOD_EXIT();

return NULL;

}

*cls = scls;

if (scls)

{

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: scls = "<<PEGASUS_STD(hex)<<(int)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Inserting global reference %p into class table.",scls));

_classTable.insert(cln,scls);

}

Line 713

Line 1033

gProv = (jobject)env->NewGlobalRef(lProv);

if (env->ExceptionCheck())

{

DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<cn<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,

"Unable to instantiate provider %s.",cn));

PEG_METHOD_EXIT();

return NULL;

}

if (gProv)

{

DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(int)gProv<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Inserting provider reference %p into object table.",gProv));

_objectTable.insert(cln,gProv);

}

PEG_METHOD_EXIT();

return gProv;

}

#if 0

// Java 1.4 version of programmatically accessting the backtrace stack

// NOTE: Renumber to follow current content

// add to:

// const char* classNames[]={

///*37*/ "java/lang/StackTraceElement"

// add to:

// const METHOD_STRUCT instanceMethodNames[]={

///*57 ThrowableGetStackTrace */ { /*Throwable */

///21, "getStackTrace", "()Ljava/lang/StackTraceElement;" },

///*58 StackTraceElementGetClassName */ { /*StackTraceElement*/

///37, "getClassName", "()Ljava/lang/String;" },

///*59 StackTraceElementGetFileName */ { /*StackTraceElement*/

///37, "getFileName", "()Ljava/lang/String;" },

///*60 StackTraceElementGetLineNumber */ { /*StackTraceElement*/

///37, "getLineNumber", "()I" },

///*61 StackTraceElementGetMethodName */ { /*StackTraceElement*/

///37, "getMethodName", "()Ljava/lang/String;" }

String getExceptionInfo (JNIEnv *env)

{

jthrowable err = env->ExceptionOccurred ();

jobjectArray stackTrace = 0;

String rc;

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"getExceptionInfo");

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"err = %ld ",(long)(jlong)err));

if (!err)

{

PEG_METHOD_EXIT();

return rc;

}

stackTrace = (jobjectArray)env->CallObjectMethod(

err,

JMPIjvm::jv.ThrowableGetStackTrace);

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"stackTrace = %p ",stackTrace));

if (!stackTrace)

{

PEG_METHOD_EXIT();

return rc;

}

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"stackTrace length = %d",(jlong)env->GetArrayLength(stackTrace)));

jobject jFirstST = 0;

jstring jClass = 0;

jstring jFile = 0;

jstring jMethod = 0;

jint jLine = 0;

jFirstST = env->GetObjectArrayElement (stackTrace, 0);

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"jFirstST = %p",jFirstST));

if (!jFirstST)

{

PEG_METHOD_EXIT();

return rc;

}

jClass = (jstring)env->CallObjectMethod(

jFirstST,

JMPIjvm::jv.StackTraceElementGetClassName);

jFile = (jstring)env->CallObjectMethod(

jFirstST,

JMPIjvm::jv.StackTraceElementGetFileName);

jMethod = (jstring)env->CallObjectMethod(

jFirstST,

JMPIjvm::jv.StackTraceElementGetMethodName);

jLine = env->CallIntMethod(

jFirstST,

JMPIjvm::jv.StackTraceElementGetLineNumber);

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"jClass = %p, jFile = %p, jMethod = %p, jLine = %p",

jClass,jFile,jMethod,jLine));

const char *pszClass = 0;

const char *pszFile = 0;

const char *pszMethod = 0;

pszClass = env->GetStringUTFChars (jClass, NULL);

pszFile = env->GetStringUTFChars (jFile, NULL);

pszMethod = env->GetStringUTFChars (jMethod, NULL);

std::ostringstream oss;

String exceptionInfo;

if (pszFile)

{

oss << "File: " << pszFile;

env->ReleaseStringUTFChars (jFile, pszFile);

}

if (jLine)

{

oss << ", Line: " << jLine;

}

if (pszClass)

{

oss << ", Class: " << pszClass;

env->ReleaseStringUTFChars (jClass, pszClass);

}

if (pszMethod)

{

oss << ", Method: " << pszMethod;

env->ReleaseStringUTFChars (jMethod, pszMethod);

}

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"oss = %s",(const char*)oss.str().c_str()));

rc = oss.str ().c_str ();

return rc;

}

#else

String getExceptionInfo (JNIEnv *env)

{

jthrowable err = env->ExceptionOccurred ();

String rc;

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"getExceptionInfo");

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"err = %ld ",(long)(jlong)err));

if (!err)

{

PEG_METHOD_EXIT();

return rc;

}

// ByteArrayOutputStream baos = new ByteArrayOutputStream ();

// PrintStream ps = new PrintStream (baos);

// e.printStackTrace (ps);

// result = baos.toString ();

jobject jBAOS = 0;

jobject jPS = 0;

jBAOS = env->NewObject (JMPIjvm::jv.ByteArrayOutputStreamClassRef,

JMPIjvm::jv.ByteArrayOutputStreamNew);

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, "jBAOS = %p ",jBAOS));

if (!jBAOS)

{

env->ExceptionDescribe ();

PEG_METHOD_EXIT();

return rc;

}

jPS = env->NewObject (JMPIjvm::jv.PrintStreamClassRef,

JMPIjvm::jv.PrintStreamNewOb,

jBAOS);

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4, "jPS = %p ",jPS));

if (!jPS)

{

PEG_METHOD_EXIT();

return rc;

}

env->CallVoidMethod (err,

JMPIjvm::jv.ThrowablePrintStackTrace,

jPS);

jstring jST = 0;

jST = (jstring)env->CallObjectMethod(

jBAOS,

JMPIjvm::jv.ByteArrayOutputStreamToString);

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,"jST = %p ",jST));

const char *pszST = 0;

pszST = env->GetStringUTFChars (jST, NULL);

if (pszST)

{

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"pszST = %s ",pszST));

rc = pszST;

env->ReleaseStringUTFChars (jST, pszST);

}

PEG_METHOD_EXIT();

return rc;

}

#endif

void JMPIjvm::checkException(JNIEnv *env)

{

if (env->ExceptionCheck ())

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"JMPIjvm::checkException");

if (!env->ExceptionCheck ())

{

PEG_METHOD_EXIT();

return;

}

jstring jMsg = NULL,

jId = NULL;

int code;

const char *cp;

String msg = String::EMPTY,

String msg;

id = String::EMPTY;

String id;

jthrowable err = env->ExceptionOccurred();

DDD(env->ExceptionDescribe());

// PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

// "err = %ld ",(long)(jlong)err));

if (!err)

{

PEG_METHOD_EXIT();

return;

}

PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL1,

"Provider caused an exception!");

env->ExceptionDescribe ();

if (env->IsInstanceOf (err, JMPIjvm::jv.CIMExceptionClassRef))

{

env->ExceptionClear ();

if (err)

{

jMsg = (jstring)env->CallObjectMethod(

jMsg = (jstring)env->CallObjectMethod (err, JMPIjvm::jv.ThrowableGetMessage);

err,

code = (int)env->CallIntMethod (err, JMPIjvm::jv.CIMExceptionGetCode);

JMPIjvm::jv.ThrowableGetMessage);

jId = (jstring)env->CallObjectMethod (err, JMPIjvm::jv.CIMExceptionGetID);

code = (int)env->CallIntMethod(

err,

JMPIjvm::jv.CIMExceptionGetCode);

jId = (jstring)env->CallObjectMethod(

err,

JMPIjvm::jv.CIMExceptionGetID);

if (jId)

{

Line 763

Line 1324

env->ReleaseStringUTFChars (jMsg, cp);

}

DDD(PEGASUS_STD(cerr)<<"--- throwing Pegasus exception: "<<code<<" "<<id<<" ("<<msg<<")"<<PEGASUS_STD(endl));

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,

"throwing Pegasus exception: %d %s (%s)",

code,(const char*)id.getCString(),(const char*)msg.getCString()));

PEG_METHOD_EXIT();

throw CIMException ((CIMStatusCode)code, id+" ("+msg+")");

}

else

{

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

String info = getExceptionInfo (env);

env->ExceptionDescribe();

exit(13);

env->ExceptionClear ();

}

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL1,

"Java caused an exception: %s",(const char*)info.getCString()));

PEG_METHOD_EXIT();

throw PEGASUS_CIM_EXCEPTION_L(

CIM_ERR_FAILED,

MessageLoaderParms(

"ProviderManager2.JMPI.JMPIImpl.JAVA_CAUSED_EXCEPTION.STANDARD",

"Java caused an exception: $0",

info));

}

Line 844

Line 1418

return (jobjectArray)ary;

}

CIMPropertyList getList(JNIEnv *jEnv, jobjectArray l)

{

CIMPropertyList pl;

Line 875

Line 1447

void throwCimException (JNIEnv *jEnv, CIMException &e)

{

JMPIjvm::cacheIDs(jEnv);

jobject ev = jEnv->NewObject(JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewI,(jint)e.getCode());

jobject ev = jEnv->NewObject(

JMPIjvm::jv.CIMExceptionClassRef,

JMPIjvm::jv.CIMExceptionNewI,

(jint)e.getCode());

jEnv->Throw((jthrowable)ev);

}

void throwFailedException (JNIEnv *jEnv)

{

JMPIjvm::cacheIDs(jEnv);

jobject ev = jEnv->NewObject(JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewI,1);

jobject ev = jEnv->NewObject(

JMPIjvm::jv.CIMExceptionClassRef,

JMPIjvm::jv.CIMExceptionNewI,

1);

jEnv->Throw((jthrowable)ev);

}

void throwNotSupportedException (JNIEnv *jEnv)

{

JMPIjvm::cacheIDs(jEnv);

jobject ev = jEnv->NewObject(JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewI,7);

jobject ev = jEnv->NewObject(

JMPIjvm::jv.CIMExceptionClassRef,

JMPIjvm::jv.CIMExceptionNewI,

7);

jEnv->Throw((jthrowable)ev);

}

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

// ---

// - CIMException

// - CIMArgument

// ---

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

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1new

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1new

(JNIEnv *jEnv, jobject jThs)

{

JMPIjvm::cacheIDs (jEnv);

CIMParamValue *p = new CIMParamValue (String::EMPTY,CIMValue ());

jEnv->CallNonvirtualVoidMethod (jThs,

return DEBUG_ConvertCToJava (CIMParamValue*, jlong, p);

JMPIjvm::jv.CIMExceptionClassRef,

JMPIjvm::jv.CIMExceptionNew);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newS

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1newS

(JNIEnv *jEnv, jobject jThs, jstring jM)

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

JMPIjvm::cacheIDs (jEnv);

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

CIMParamValue *p = new CIMParamValue (str, CIMValue ());

jEnv->CallNonvirtualVoidMethod (jThs,

jEnv->ReleaseStringUTFChars (jN, str);

JMPIjvm::jv.CIMExceptionClassRef,

JMPIjvm::jv.CIMExceptionNewSt,

return DEBUG_ConvertCToJava (CIMParamValue*, jlong, p);

jM);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSO

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1newSV

(JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1)

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

{

JMPIjvm::cacheIDs (jEnv);

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

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

CIMParamValue *p = 0;

jEnv->CallNonvirtualVoidMethod (jThs,

if ( str

JMPIjvm::jv.CIMExceptionClassRef,

&& cv

JMPIjvm::jv.CIMExceptionNewStOb,

)

jM,

{

jO1);

p = new CIMParamValue (str, *cv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSOO

jEnv->ReleaseStringUTFChars (jN, str);

(JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1, jobject jO2)

{

JMPIjvm::cacheIDs (jEnv);

jEnv->CallNonvirtualVoidMethod (jThs,

return DEBUG_ConvertCToJava (CIMParamValue*, jlong, p);

JMPIjvm::jv.CIMExceptionClassRef,

JMPIjvm::jv.CIMExceptionNewStObOb,

jM,

jO1,

jO2);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSOOO

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1getType

(JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1, jobject jO2, jobject jO3)

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

JMPIjvm::cacheIDs (jEnv);

CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);

const CIMValue cv = cp->getValue ();

String ref;

bool fSuccess = false;

int iJType = 0;

_dataType *type = 0;

jEnv->CallNonvirtualVoidMethod (jThs,

iJType = _dataType::convertCTypeToJavaType (cv.getType (), &fSuccess);

JMPIjvm::jv.CIMExceptionClassRef,

JMPIjvm::jv.CIMExceptionNewStObObOb,

if (fSuccess)

jM,

{

jO1,

type = new _dataType (iJType,

jO2,

cv.getArraySize (),

jO3);

false,

cv.isArray (),

ref,

true);

}

return DEBUG_ConvertCToJava (_dataType*, jlong, type);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setValue

(JNIEnv *jEnv, jobject jThs, jlong jP,jlong jV)

{

CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);

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

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

cp->setValue (*cv);

// ---

}

// - CIMOMHandle

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getClass

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1getValue

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

(JNIEnv *jEnv, jobject jThs, jlong jP)

jboolean iq, jboolean ic, jobjectArray jPl)

{

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

CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);

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

CIMValue *cv = new CIMValue (cp->getValue ());

CIMPropertyList pl;

OperationContext ctx;

if (jPl)

pl = getList (jEnv, jPl);

else

pl = CIMPropertyList ();

try {

CIMClass cls = ch->getClass (ctx,

cop->getNameSpace (),

cop->getClassName (),

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,

pl);

return DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass (cls));

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

Catch(jEnv);

return 0;

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMArgument__1getName

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);

const String &n = cp->getParameterName ();

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

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createClass

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setName

(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCl)

(JNIEnv *jEnv, jobject jThs, jlong jP, jstring jN)

{

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

CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);

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

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

CIMClass *cl = DEBUG_ConvertJavaToC (jint, CIMClass*, jCl);

String n (str);

OperationContext ctx;

try {

cp->setParameterName (n);

ch->createClass (ctx,

cop->getNameSpace (),

jEnv->ReleaseStringUTFChars (jN, str);

*cl);

}

Catch(jEnv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setClass

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1finalize

(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCl)

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

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

CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);

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

CIMClass *cl = DEBUG_ConvertJavaToC (jint, CIMClass*, jCl);

OperationContext ctx;

try {

delete cp;

ch->modifyClass (ctx,

cop->getNameSpace (),

DEBUG_ConvertCleanup (jlong, jP);

*cl);

}

Catch(jEnv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteClass

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

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

// ---

// - CIMClass

// ---

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

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1newInstance

(JNIEnv *jEnv, jobject jThs, jlong jCls)

{

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

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

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

OperationContext ctx;

try {

if (cls)

ch->deleteClass (ctx,

{

cop->getNameSpace (),

try

cop->getClassName ());

{

CIMInstance *ci = new CIMInstance (cls->getClassName ());

CIMObjectPath copNew = ci->getPath ();

copNew.setNameSpace (cls->getPath ().getNameSpace ());

ci->setPath (copNew);

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

{

try

{

ci->addQualifier (cls->getQualifier (i).clone ());

}

Catch(jEnv);

catch(Exception e)

{

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClassNames

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

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

{

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

CIMProperty cp = cls->getProperty (i);

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

CIMNamespaceName ns = cop->getNameSpace ();

OperationContext ctx;

try {

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

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

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

{

try

{

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

}

catch (Exception e)

{

enmop->append (CIMObjectPath (String::EMPTY,

ns,

enm[i]));

}

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

}

return DEBUG_ConvertCToJava (CIMInstance*, jlong, ci);

}

Catch(jEnv);

}

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClasses

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1filterProperties

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

(JNIEnv *jEnv,

jboolean lo, jboolean iq, jboolean ic)

jobject jThs,

jlong jInst,

jobjectArray jPl,

jboolean iq,

jboolean ic,

jboolean lo)

{

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

CIMClass *cc = DEBUG_ConvertJavaToC (jlong, CIMClass*, jInst);

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

CIMClass *cf = 0;

OperationContext ctx;

CIMName clsn = cc->getClassName ();

try {

if (lo)

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

{

cop->getNameSpace (),

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

cop->getClassName (),

(Boolean)deep,

CIMName clsn = cc->getClassName ();

(Boolean)lo,

(Boolean)iq,

(Boolean)ic);

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

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

{

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

cf->removeProperty (i);

}

Catch (jEnv);

return 0;

return DEBUG_ConvertCToJava (CIMClass*, jlong, cf);

}

else if (jPl)

{

CIMPropertyList pl = getList (jEnv,jPl);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getInstance

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

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

jobjectArray jPl)

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

{

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

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

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

OperationContext ctx;

CIMPropertyList pl;

if (jPl)

if (pos != PEG_NOT_FOUND)

pl = getList (jEnv,jPl);

{

else

if (iq)

pl = CIMPropertyList ();

{

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

try {

if (!ic)

CIMInstance *inst = new CIMInstance (ch->getInstance (ctx,

cp.setClassOrigin (CIMName ());

cop->getNameSpace (),

*cop,

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,

pl));

return DEBUG_ConvertCToJava (CIMInstance*, jint, inst);

cf->addProperty (cp);

}

Catch (jEnv);

else

{

CIMProperty cp = cc->getProperty (pos);

CIMName co;

return 0;

if (ic)

}

co = cp.getClassOrigin ();

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance

CIMProperty np (cp.getName (),

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

cp.getValue (),

{

cp.getArraySize (),

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

cp.getReferenceClassName (),

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

co,

OperationContext ctx;

cp.getPropagated ());

try {

cf->addProperty (np);

ch->deleteInstance (ctx,cop->getNameSpace (),*cop);

}

Catch (jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createInstance

if (iq)

(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCi)

{

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

for (Uint32 i = 0, s = cc->getQualifierCount (); i < s; i++)

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

{

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

cf->addQualifier (cc->getQualifier (i));

OperationContext ctx;

}

else if (iq)

{

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

try {

if (ic)

ci->setPath (*cop);

return DEBUG_ConvertCToJava (CIMClass*, jlong, cf);

CIMObjectPath obj = ch->createInstance (ctx,

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

cop->getNameSpace (),

{

*ci);

CIMProperty cp = cf->getProperty (i);

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath (obj));

cp.setClassOrigin (CIMName ());

cf->removeProperty (i);

cf->addProperty (cp);

}

Catch (jEnv);

return 0;

}

else

{

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

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1modifyInstance

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

(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCi,

jboolean iq, jobjectArray jPl)

{

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

CIMProperty cp = cc->getProperty (i);

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

CIMName co;

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

CIMPropertyList pl = getList (jEnv, jPl);

OperationContext ctx;

try {

if (ic)

ci->setPath (*cop);

co = cp.getClassOrigin ();

ch->modifyInstance (ctx,

cop->getNameSpace (),

CIMProperty np (cp.getName (),

*ci,

cp.getValue (),

(Boolean)iq,

cp.getArraySize (),

pl);

cp.getReferenceClassName (),

co,

cp.getPropagated ());

cf->addProperty (np);

}

Catch (jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstanceNames

return DEBUG_ConvertCToJava (CIMClass*, jlong, cf);

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

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getName

(JNIEnv *jEnv, jobject jThs, jlong jCls)

{

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

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

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

OperationContext ctx;

try {

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

const String &cn = cls->getClassName ().getString ();

cop->getNameSpace (),

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

cop->getClassName ()); //, (Boolean)deep);

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

return str;

}

Catch (jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstances

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifier

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

(JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jN)

jboolean lo, jboolean iq, jboolean ic, jobjectArray jPl)

{

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

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

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

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

CIMPropertyList pl;

jlong rv = 0;

OperationContext ctx;

Uint32 pos = cls->findQualifier (String (str));

if (jPl)

if (pos != PEG_NOT_FOUND)

pl = getList (jEnv, jPl);

rv = DEBUG_ConvertCToJava (CIMQualifier*,

else

jlong,

pl = CIMPropertyList ();

new CIMQualifier (cls->getQualifier (pos)));

try {

jEnv->ReleaseStringUTFChars (jN, str);

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

cop->getNameSpace (),

cop->getClassName (),

(Boolean)deep,

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,

pl);

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

return rv;

}

Catch (jEnv);

return 0;

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifiers

}

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

{

JMPIjvm::cacheIDs (jEnv);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1execQuery

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

(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jQuery, jstring jQl)

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

{

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

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

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

jlong jCq = DEBUG_ConvertCToJava (CIMQualifier*, jlong, cq);

OperationContext ctx;

jobject qual = jEnv->NewObject(

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

JMPIjvm::jv.CIMQualifierClassRef,

String query (str);

JMPIjvm::jv.CIMQualifierNewJ,

jCq);

jEnv->ReleaseStringUTFChars (jQuery,str);

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

}

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

return jVec;

}

String ql (str);

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1hasQualifier

(JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jQ)

{

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

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

Uint32 pos = cls->findQualifier (String (str));

jEnv->ReleaseStringUTFChars (jQl, str);

jEnv->ReleaseStringUTFChars (jQ,str);

try {

return (jboolean)(pos != PEG_NOT_FOUND);

Array<CIMObject> enm = ch->execQuery (ctx,

}

cop->getNameSpace (),

ql,

query);

Array<CIMInstance> *enmInst = new Array<CIMInstance> ();

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

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1addProperty

(JNIEnv *jEnv, jobject jThs, jlong jCls, jlong jP)

{

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

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

}

CIMProperty *p = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

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

try

{

cls->addProperty (*p);

}

Catch (jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1setProperties

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

{

JMPIjvm::cacheIDs (jEnv);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getProperty

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

(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jN)

{

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

cls->removeProperty (i);

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

}

OperationContext ctx;

for (Uint32 i = 0, s = jEnv->CallIntMethod(

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

jVec,

CIMName prop (str);

JMPIjvm::jv.VectorSize); i < s; i++)

{

JMPIjvm::checkException (jEnv);

jEnv->ReleaseStringUTFChars (jN, str);

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

jlong jp = jEnv->CallLongMethod(o,JMPIjvm::jv.CIMPropertyCInst);

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

try {

JMPIjvm::checkException (jEnv);

CIMValue *cv = new CIMValue (ch->getProperty (ctx,

cop->getNameSpace (),

*cop,

prop));

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

cls->addProperty (*cp);

}

Catch (jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setProperty

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperty

(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jPn, jint jV)

(JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jN)

{

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

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

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

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

OperationContext ctx;

jlong rv = 0;

CIMValue *val = (CIMValue*)jCop;

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

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

CIMName pName (str);

jEnv->ReleaseStringUTFChars (jPn, str);

if (pos != PEG_NOT_FOUND)

rv = DEBUG_ConvertCToJava (CIMProperty*,

jlong,

new CIMProperty (cls->getProperty (pos)));

try {

jEnv->ReleaseStringUTFChars (jN,str);

ch->setProperty (ctx,

cop->getNameSpace (),

return rv;

*cop,

pName,

*val);

}

Catch (jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties

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

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

{

JMPIjvm::cacheIDs (jEnv);

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

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

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

OperationContext ctx;

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

CIMName method (str);

jEnv->ReleaseStringUTFChars (jMn,str);

Array<CIMParamValue> in;

Array<CIMParamValue> out;

for (int i = 0, m = jEnv->CallIntMethod (jIn,JMPIjvm::jv.VectorSize); i < m; i++)

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

{

JMPIjvm::checkException (jEnv);

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

jlong jCp = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp);

jobject prop = jEnv->NewObject(

JMPIjvm::jv.CIMPropertyClassRef,

JMPIjvm::jv.CIMPropertyNewJ,

jCp);

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

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

}

JMPIjvm::checkException (jEnv);

return jVec;

}

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

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1new

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

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

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

CIMClass *cls = new CIMClass (CIMName (str), CIMName ());

JMPIjvm::checkException (jEnv);

jEnv->ReleaseStringUTFChars (jN,str);

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

return DEBUG_ConvertCToJava (CIMClass*, jlong, cls);

}

try {

CIMValue *val = new CIMValue (ch->invokeMethod (ctx,

cop->getNameSpace (),

*cop,

method,

in,

out));

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

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getSuperClass

(JNIEnv *jEnv, jobject jThs, jlong jCls)

{

const CIMParamValue &parm = out[i];

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

const CIMValue v = parm.getValue ();

const String &cn = cls->getSuperClassName ().getString ();

CIMProperty *p = new CIMProperty (parm.getParameterName (),

v.getArraySize ());

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

jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,

JMPIjvm::jv.CIMPropertyNewI,

jp);

jEnv->CallVoidMethod (jOut, JMPIjvm::jv.VectorAddElement, prop);

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

}

return DEBUG_ConvertCToJava (CIMValue*, jint, val);

}

Catch (jEnv);

return 0;

return str;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod24

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getKeys

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

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

jobjectArray jIn, jobjectArray jOut)

{

JMPIjvm::cacheIDs (jEnv);

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

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

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

OperationContext ctx;

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

CIMName method (str);

jEnv->ReleaseStringUTFChars (jMn, str);

if (cls->hasKeys ())

{

Array<CIMName> keyNames;

Array<CIMParamValue> in;

cls->getKeyNames (keyNames);

Array<CIMParamValue> out;

if (jIn)

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

{

for (int i = 0, m = jEnv->GetArrayLength (jIn); i < m; i++)

Uint32 pos = cls->findProperty (keyNames[i]);

if (pos != PEG_NOT_FOUND)

{

JMPIjvm::checkException (jEnv);

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

jlong jCp = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp);

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

jobject prop = jEnv->NewObject(

JMPIjvm::jv.CIMPropertyClassRef,

JMPIjvm::jv.CIMPropertyNewJ,

jCp);

JMPIjvm::checkException (jEnv);

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

}

jint jp = jEnv->CallIntMethod (jArg,JMPIjvm::jv.CIMArgumentCInst);

return jVec;

CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jp);

}

JMPIjvm::checkException (jEnv);

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethod

(JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jN)

{

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

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

jlong rv = 0;

Uint32 pos = cls->findMethod (String (str));

in.append (*p);

if (pos != PEG_NOT_FOUND)

{

rv = DEBUG_ConvertCToJava(

CIMMethod*,

jlong,

new CIMMethod(cls->getMethod(pos)));

}

jEnv->ReleaseStringUTFChars (jN,str);

return rv;

}

try {

CIMValue *val = new CIMValue (ch->invokeMethod (ctx,

cop->getNameSpace (),

*cop,

method,

in,

out));

if (jOut)

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1equals

{

(JNIEnv *jEnv, jobject jThs, jlong jCls, jlong jClsToBeCompared)

for (int i = 0, m = out.size (), o = jEnv->GetArrayLength (jOut); i < m && i< o; i++)

{

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

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

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

CIMClass *clsToBeCompared = DEBUG_ConvertJavaToC(

jlong,

CIMClass*,

jClsToBeCompared);

bool fRc = false;

jEnv->SetObjectArrayElement (jOut,i,

if ( cls && clsToBeCompared )

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

{

}

try

}

{

return DEBUG_ConvertCToJava (CIMValue*, jint, val);

fRc = cls->identical (*clsToBeCompared);

}

Catch (jEnv);

}

return 0;

return fRc;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associatorNames

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1isAssociation

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

(JNIEnv *jEnv, jobject jThs, jlong jCls)

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

{

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

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

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

jboolean rv = false;

OperationContext ctx;

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

CIMName assocClass;

if ( str

if (cls)

&& *str

)

{

if (CIMName::legal (str))

try

{

assocClass = str;

rv = cls->isAssociation ();

}

else

Catch (jEnv);

}

return rv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1findMethod

(JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jName)

{

jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,

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

JMPIjvm::jv.CIMExceptionNewISt,

jint rv = -1;

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF ("Invalid association class name"));

jEnv->Throw ((jthrowable)ev);

if (cls)

{

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

return 0;

try

}

{

CIMName name (cstrName);

rv = cls->findMethod (name);

}

Catch (jEnv);

jEnv->ReleaseStringUTFChars (jAssocClass, str);

jEnv->ReleaseStringUTFChars (jName, cstrName);

}

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

return rv;

}

CIMName resultClass;

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethodI

(JNIEnv *jEnv, jobject jThs, jlong jCls, jint jMethod)

{

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

jlong rv = 0;

if ( str

if (cls && jMethod >=0)

&& *str

)

{

if (CIMName::legal (str))

try

{

resultClass = str;

CIMMethod cm = cls->getMethod (jMethod);

rv = DEBUG_ConvertCToJava (CIMMethod *, jlong, new CIMMethod (cm));

}

else

Catch (jEnv);

}

return rv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethodCount

(JNIEnv *jEnv, jobject jThs, jlong jCls)

{

jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,

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

JMPIjvm::jv.CIMExceptionNewISt,

jint rv = 0;

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF ("Invalid result class name"));

jEnv->Throw ((jthrowable)ev);

if (cls)

{

try

{

rv = cls->getMethodCount ();

}

Catch (jEnv);

}

return 0;

return rv;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jCls)

{

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

delete cls;

DEBUG_ConvertCleanup (jlong, jCls);

}

jEnv->ReleaseStringUTFChars (jResultClass, str);

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

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

// ---

// - CIMClient

// ---

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

String role (str);

void checkNs (CIMObjectPath *cop, jlong jNs)

{

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

{

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

jEnv->ReleaseStringUTFChars (jRole, str);

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

}

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

static int normalizeNs (String &ns, String &nsBase, String &lastNsComp)

{

Uint32 n = ns.size ();

String resultRole (str);

if (ns[n-1] == '/')

{

if (n >= 2)

ns = ns.subString (0, n-2);

}

jEnv->ReleaseStringUTFChars (jResultRole, str);

lastNsComp = ns;

nsBase = "root";

try {

n = ns.reverseFind ('/');

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

cop->getNameSpace (),

*cop,

assocClass,

resultClass,

role,

resultRole);

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

if (n != PEG_NOT_FOUND)

{

lastNsComp = ns.subString (n+1);

nsBase = ns.subString (0, n);

}

Catch (jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associators

Boolean verifyServerCertificate (SSLCertificateInfo &certInfo)

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

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

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)

{

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

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

OperationContext ctx;

CIMPropertyList pl = getList (jEnv, jPl);

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

CIMName assocClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

// If server certificate was found in CA trust store and validated, then

// return 'true' to accept the certificate, otherwise return 'false'.

if (certInfo.getResponseCode () == 1)

{

assocClass = str;

return true;

}

else

{

jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,

return false;

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

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1newNaUnPw

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

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

{

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

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

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

jlong jCc = 0;

CIMName resultClass;

SSLContext *sslContext = 0; // initialized for unencrypted connection

if ( str

#ifdef PEGASUS_HAS_SSL

&& *str

if (cNs->isHttps ())

)

{

if (CIMName::legal (str))

try

{

resultClass = str;

sslContext = new SSLContext (PEGASUS_SSLCLIENT_CERTIFICATEFILE,

verifyServerCertificate,

PEGASUS_SSLCLIENT_RANDOMFILE);

}

else

catch (Exception &e)

{

jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,

cerr << "JMPI: Error: could not create SSLContext: "

JMPIjvm::jv.CIMExceptionNewISt,

<< e.getMessage() << endl;

(jint)4, // CIM_ERR_INVALID_PARAMETER

return jCc;

jEnv->NewStringUTF ("Invalid result class name"));

}

#endif

jEnv->Throw ((jthrowable)ev);

try {

CIMClient *cc = new CIMClient ();

return 0;

if (sslContext)

{

cc->connect (cNs->hostName (), cNs->port (), *sslContext, un, pw);

}

else

{

cc->connect (cNs->hostName (), cNs->port (), un, pw);

}

jEnv->ReleaseStringUTFChars (jResultClass, str);

jCc = DEBUG_ConvertCToJava (CIMClient*, jlong, cc);

}

Catch (jEnv);

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

jEnv->ReleaseStringUTFChars (jUn, un);

jEnv->ReleaseStringUTFChars (jPw, pw);

String role (str);

delete sslContext;

jEnv->ReleaseStringUTFChars (jRole, str);

return jCc;

}

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

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1disconnect

(JNIEnv *jEnv, jobject jThs, jlong jCc)

{

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

String resultRole (str);

try {

cCc->disconnect ();

}

Catch (jEnv);

}

jEnv->ReleaseStringUTFChars (jResultRole, str);

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1getClass

(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jboolean lo,

jboolean iq, jboolean ic, jobjectArray jPl)

{

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

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

CIMPropertyList pl = getList (jEnv, jPl);

if ( cCc

&& cop

)

{

try {

Array<CIMObject> enm = ch->associators (ctx,

checkNs (cop, jNs);

cop->getNameSpace (),

*cop,

CIMClass cls = cCc->getClass (cop->getNameSpace (),

assocClass,

cop->getClassName (),

resultClass,

(Boolean)lo,

role,

(Boolean)iq,

resultRole,

(Boolean)ic,

(Boolean)includeQualifiers,

(Boolean)includeClassOrigin,

pl);

Array<CIMInstance> *enmInst = new Array<CIMInstance> ();

CIMObjectPath copNew = cls.getPath ();

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

copNew.setNameSpace (cop->getNameSpace ());

{

cls.setPath (copNew);

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

}

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

return DEBUG_ConvertCToJava (CIMClass*, jlong, new CIMClass (cls));

}

Catch (jEnv);

}

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1referenceNames

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteClass

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

(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop)

jstring jAssocClass, jstring jRole)

{

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

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

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

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

OperationContext ctx;

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

CIMName assocClass;

if ( str

try {

&& *str

checkNs (cop, jNs);

)

{

cCc->deleteClass (cop->getNameSpace (),

if (CIMName::legal (str))

cop->getClassName ());

{

}

assocClass = str;

Catch (jEnv);

}

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

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createClass

(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jlong jCl)

{

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

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

CIMClass *cl = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCl);

return 0;

try {

cCc->createClass (cop->getNameSpace (), *cl);

}

Catch (jEnv);

}

jEnv->ReleaseStringUTFChars (jAssocClass, str);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setClass

(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jlong jCl)

{

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

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

CIMClass *cl = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCl);

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

try {

checkNs (cop, jNs);

String role (str);

cCc->modifyClass (cop->getNameSpace (), *cl);

}

Catch (jEnv);

}

jEnv->ReleaseStringUTFChars (jRole, str);

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1getInstance

(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jboolean lo,

jboolean iq, jboolean ic, jobjectArray jPl)

{

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

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

CIMPropertyList pl = getList (jEnv, jPl);

try {

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

checkNs (cop, jNs);

cop->getNameSpace (),

CIMInstance inst = cCc->getInstance (cop->getNameSpace (),

*cop,

assocClass,

(Boolean)lo,

role);

(Boolean)iq,

(Boolean)ic,

pl);

inst.setPath (*cop);

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

return DEBUG_ConvertCToJava (CIMInstance*, jlong, new CIMInstance (inst));

}

Catch (jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1references

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteInstance

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

(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop)

jstring jAssocClass, jstring jRole,

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)

{

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

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

OperationContext ctx;

CIMPropertyList pl = getList (jEnv, jPl);

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

CIMName assocClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

else

{

jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,

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

JMPIjvm::jv.CIMExceptionNewISt,

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

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF ("Invalid association class name"));

jEnv->Throw ((jthrowable)ev);

try {

checkNs (cop, jNs);

return 0;

cCc->deleteInstance (cop->getNameSpace (), *cop);

}

Catch (jEnv);

}

jEnv->ReleaseStringUTFChars (jAssocClass, str);

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1createInstance

(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jlong jCi)

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

{

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

String role (str);

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

CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jCi);

jEnv->ReleaseStringUTFChars (jRole, str);

try {

Array<CIMObject> enm = ch->references (ctx,

checkNs (cop, jNs);

cop->getNameSpace (),

*cop,

assocClass,

role,

(Boolean)includeQualifiers,

(Boolean)includeClassOrigin,

pl);

Array<CIMInstance> *enmInst = new Array<CIMInstance> ();

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

ci->setPath (*cop);

{

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

CIMObjectPath obj = cCc->createInstance (cop->getNameSpace (), *ci);

}

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

return DEBUG_ConvertCToJava(CIMObjectPath*,jlong,new CIMObjectPath (obj));

}

Catch (jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1modifyInstance

(JNIEnv *jEnv, jobject jThs, jint jCh, jstring jName, jstring jNs, jint jInd)

(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jlong jCi,

jboolean iq, jobjectArray jPl)

{

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

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

CIMInstance *ind = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInd);

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

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

CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jCi);

String name (str);

CIMPropertyList pl = getList (jEnv, jPl);

jEnv->ReleaseStringUTFChars (jName, str);

try {

checkNs (cop, jNs);

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

ci->setPath (*cop);

String ns (str);

cCc->modifyInstance (cop->getNameSpace (), *ci, (Boolean)iq, pl);

}

Catch (jEnv);

}

jEnv->ReleaseStringUTFChars (jNs, str);

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClasses(

JNIEnv *jEnv,

jobject jThs,

jlong jCc,

jlong jNs,

jlong jCop,

jboolean deep,

jboolean lo,

jboolean iq,

jboolean ic)

{

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

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

CIMObjectPath ref (ind->getPath ());

try {

checkNs (cop, jNs);

ref.setNameSpace (ns);

Array<CIMClass> enm = cCc->enumerateClasses (cop->getNameSpace (),

DDD (PEGASUS_STD (cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent () ref = "<<ref.toString ()<<PEGASUS_STD (endl));

cop->getClassName (),

DDD (PEGASUS_STD (cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent () ind = "<<ind->getPath ().toString ()<<PEGASUS_STD (endl));

(Boolean)deep,

ind->setPath (ref);

(Boolean)lo,

DDD (PEGASUS_STD (cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent () ind = "<<ind->getPath ().toString ()<<PEGASUS_STD (endl));

(Boolean)iq,

(Boolean)ic);

JMPIProviderManager::indProvRecord *prec = NULL;

return DEBUG_ConvertCToJava(

String sPathString = ind->getPath ().toString ();

Array<CIMClass>*,

OperationContext *context = NULL;

jlong,

bool fResult = false;

new Array<CIMClass> (enm));

}

Catch (jEnv);

return 0;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClassNames

(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jboolean deep)

{

AutoMutex lock (JMPIProviderManager::mutexProvTab);

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

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

CIMNamespaceName ns = cop->getNameSpace ();

fResult = JMPIProviderManager::provTab.lookup (name, prec);

try {

checkNs (cop, jNs);

DDD (PEGASUS_STD (cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent () fResult = "<<fResult<<", name = "<<name<<PEGASUS_STD (endl));

Array<CIMName> enm = cCc->enumerateClassNames(ns,

}

cop->getClassName(),

(Boolean)deep);

Array<CIMObjectPath> *enmop = new Array<CIMObjectPath> ();

if (fResult)

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

{

if (prec->enabled)

{

try

{

prec->handler->deliver (*prec->ctx, *ind);

enmop->append (CIMObjectPath (String::EMPTY, ns, enm[i]));

}

Catch (jEnv);

}

else

{

return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jlong, enmop);

DDD (PEGASUS_STD (cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent () provider name \""<<name<<"\" not found"<<PEGASUS_STD (endl));

}

Catch (jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1finalize

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstanceNames

(JNIEnv *jEnv, jobject jThs, jint jCh)

(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jboolean deep)

{

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

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

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

delete ch;

try {

checkNs (cop,jNs);

Array<CIMObjectPath> enm = cCc->enumerateInstanceNames(

cop->getNameSpace(),

cop->getClassName ()); //, (Boolean)deep);

DEBUG_ConvertCleanup (jint, jCh);

return DEBUG_ConvertCToJava(

Array<CIMObjectPath>*,

jlong,

new Array<CIMObjectPath> (enm));

}

Catch (jEnv);

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

return 0;

// ---

}

// - CIMClass

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1newInstance

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstances(

(JNIEnv *jEnv, jobject jThs, jint jCls)

JNIEnv *jEnv,

jobject jThs,

jlong jCc,

jlong jNs,

jlong jCop,

jboolean deep,

jboolean lo,

jboolean iq,

jboolean ic,

jobjectArray jPl)

{

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

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

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

CIMPropertyList pl = getList (jEnv,jPl);

if (cls)

{

try {

CIMInstance *ci = new CIMInstance (cls->getClassName ());

checkNs (cop, jNs);

CIMObjectPath copNew = ci->getPath ();

copNew.setNameSpace (cls->getPath ().getNameSpace ());

CIMPropertyList props;

ci->setPath (copNew);

Array<CIMInstance> enm = cCc->enumerateInstances (cop->getNameSpace (),

cop->getClassName (),

(Boolean)deep,

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,pl);

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

return DEBUG_ConvertCToJava(

{

Array<CIMInstance>*,

try {

jlong,

ci->addQualifier (cls->getQualifier (i).clone ());

new Array<CIMInstance> (enm));

}

catch (Exception e) {}

Catch (jEnv);

}

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

{

CIMProperty cp = cls->getProperty (i);

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

return 0;

}

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

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateQualifiers

(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop)

{

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

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

try {

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

checkNs (cop, jNs);

}

catch (Exception e) {}

Array<CIMQualifierDecl> enm=cCc->enumerateQualifiers(cop->getNameSpace());

}

return DEBUG_ConvertCToJava (CIMInstance*, jint, ci);

return DEBUG_ConvertCToJava(

Array<CIMQualifierDecl>*,

jlong,

new Array<CIMQualifierDecl> (enm));

}

Catch (jEnv);

}

return 0;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getName

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1getQualifier

(JNIEnv *jEnv, jobject jThs, jint jCls)

(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop)

{

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

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

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

try {

const String &cn = cls->getClassName ().getString ();

checkNs (cop,jNs);

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

return str;

CIMQualifierDecl *val = new CIMQualifierDecl(

cCc->getQualifier(

cop->getNameSpace (),

cop->getClassName ()));

return DEBUG_ConvertCToJava (CIMQualifierDecl*, jlong, val);

}

Catch (jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifier

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setQualifier

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

(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jlong jQ)

{

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

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

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

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

jint rv = 0;

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

Uint32 pos = cls->findQualifier (String (str));

if (pos!= PEG_NOT_FOUND)

rv = DEBUG_ConvertCToJava (CIMQualifier*, jint, new CIMQualifier (cls->getQualifier (pos)));

jEnv->ReleaseStringUTFChars (jN, str);

try {

checkNs (cop, jNs);

return rv;

cCc->setQualifier (cop->getNameSpace (), *qt);

}

Catch (jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperty

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteQualifier

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

(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop)

{

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

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

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

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

jint rv = 0;

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

if (pos!= PEG_NOT_FOUND)

rv = DEBUG_ConvertCToJava (CIMProperty*, jint, new CIMProperty (cls->getProperty (pos)));

jEnv->ReleaseStringUTFChars (jN,str);

try {

checkNs (cop, jNs);

return rv;

cCc->deleteQualifier (cop->getNameSpace (), cop->getClassName ());

}

Catch (jEnv);

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1hasQualifier

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty

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

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

{

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

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

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

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

Uint32 pos = cls->findQualifier (String (str));

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

CIMName pName (str);

jlong jCv = 0;

jEnv->ReleaseStringUTFChars (jQ,str);

try {

checkNs (cop, jNs);

return (jboolean) (pos!= PEG_NOT_FOUND);

CIMValue *val = new CIMValue(cCc->getProperty(

cop->getNameSpace(),

*cop,

pName));

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

}

Catch (jEnv);

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties

jEnv->ReleaseStringUTFChars (jPn, str);

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

{

JMPIjvm::cacheIDs (jEnv);

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

return jCv;

}

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

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty(

{

JNIEnv *jEnv,

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

jobject jThs,

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

jlong jCc,

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

jlong jNs,

jlong jCop,

jstring jPn,

jlong jV)

{

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

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

CIMValue *val = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);

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

CIMName pName (str);

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

try {

checkNs (cop,jNs);

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

}

Catch (jEnv);

return jVec;

jEnv->ReleaseStringUTFChars (jPn, str);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1addProperty

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery(

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

JNIEnv *jEnv,

jobject jThs,

jlong jCc,

jlong jNs,

jlong jCop,

jstring jQuery,

jstring jQl)

{

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

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

CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);

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

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

String query (str);

try

jEnv->ReleaseStringUTFChars (jQuery, str);

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

String ql (str);

jEnv->ReleaseStringUTFChars (jQl, str);

try {

checkNs (cop, jNs);

Array<CIMObject> enm = cCc->execQuery (cop->getNameSpace (),

ql,

query);

Array<CIMInstance> *enmInst = new Array<CIMInstance> ();

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

{

cls->addProperty (*p);

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

}

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

}

Catch (jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1setProperties

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod(

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

JNIEnv *jEnv,

jobject jThs,

jlong jCc,

jlong jNs,

jlong jCop,

jstring jMn,

jobject jIn,

jobject jOut)

{

JMPIjvm::cacheIDs (jEnv);

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

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

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

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

CIMName method (str);

jlong jCv = 0;

Array<CIMParamValue> in;

Array<CIMParamValue> out;

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

for (int i = 0,m = jEnv->CallIntMethod(jIn,JMPIjvm::jv.VectorSize); i<m; i++)

{

cls->removeProperty (i);

}

for (Uint32 i = 0, s = jEnv->CallIntMethod (jVec, JMPIjvm::jv.VectorSize); i < s; i++)

{

JMPIjvm::checkException (jEnv);

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

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

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

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

JMPIjvm::checkException (jEnv);

cls->addProperty (*cp);

jlong jp = jEnv->CallLongMethod(jProp,JMPIjvm::jv.CIMPropertyCInst);

}

CIMProperty *p = DEBUG_ConvertJavaToC(jlong, CIMProperty*, jp);

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifiers

JMPIjvm::checkException (jEnv);

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

{

JMPIjvm::cacheIDs (jEnv);

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

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

}

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

try {

{

checkNs (cop, jNs);

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

jint jCq = DEBUG_ConvertCToJava (CIMQualifier*, jint, cq);

jobject qual = jEnv->NewObject (JMPIjvm::jv.CIMQualifierClassRef,JMPIjvm::jv.CIMQualifierNewI,jCq);

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

}

return jVec;

CIMValue *val = new CIMValue(

}

cCc->invokeMethod(

cop->getNameSpace(),

*cop,

method,

in,

out));

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1new

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

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

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

const CIMParamValue &parm = out[i];

CIMClass *cls = new CIMClass (CIMName (str), CIMName ());

const CIMValue v = parm.getValue ();

CIMProperty *p = new CIMProperty(

jEnv->ReleaseStringUTFChars (jN,str);

parm.getParameterName(),

v.getArraySize());

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

jobject prop = jEnv->NewObject(

JMPIjvm::jv.CIMPropertyClassRef,

JMPIjvm::jv.CIMPropertyNewJ,

jp);

return DEBUG_ConvertCToJava (CIMClass*, jint, cls);

jEnv->CallVoidMethod (jOut,JMPIjvm::jv.VectorAddElement,prop);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getSuperClass

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

(JNIEnv *jEnv, jobject jThs, jint jCls)

}

{

Catch (jEnv);

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

const String &cn = cls->getSuperClassName ().getString ();

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

jEnv->ReleaseStringUTFChars (jMn,str);

return str;

return jCv;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getKeys

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod24

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

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

jobjectArray jIn, jobjectArray jOut)

{

JMPIjvm::cacheIDs (jEnv);

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

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

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

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

CIMName method (str);

jlong jCv = 0;

Array<CIMParamValue> in;

Array<CIMParamValue> out;

if (cls->hasKeys ())

if (jIn)

{

Array<CIMName> keyNames;

for (int i = 0, m = jEnv->GetArrayLength (jIn); i < m; i++)

{

JMPIjvm::checkException (jEnv);

cls->getKeyNames (keyNames);

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

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

JMPIjvm::checkException (jEnv);

{

Uint32 pos = cls->findProperty (keyNames[i]);

if (pos!= PEG_NOT_FOUND)

jlong jp = jEnv->CallLongMethod (jArg,JMPIjvm::jv.CIMArgumentCInst);

{

CIMParamValue *p = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jp);

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

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

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

JMPIjvm::checkException (jEnv);

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

in.append (*p);

}

try {

checkNs (cop,jNs);

return jVec;

CIMValue *val = new CIMValue (cCc->invokeMethod (cop->getNameSpace (),

}

*cop,

method,

in,

out));

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethod

if (jOut)

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

{

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

for (int i=0,m=out.size(),o=jEnv->GetArrayLength(jOut);i<m && i<o;i++)

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

jint rv = 0;

Uint32 pos = cls->findMethod (String (str));

if (pos!= PEG_NOT_FOUND)

{

rv = DEBUG_ConvertCToJava (CIMMethod*, jint, new CIMMethod (cls->getMethod (pos)));

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

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

jEnv->SetObjectArrayElement(

jOut,

jEnv->NewObject(

JMPIjvm::jv.CIMArgumentClassRef,

JMPIjvm::jv.CIMArgumentNewJ,

jParm));

}

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

}

Catch (jEnv);

jEnv->ReleaseStringUTFChars (jN,str);

jEnv->ReleaseStringUTFChars (jMn, str);

return rv;

return jCv;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1equals

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1associatorNames(

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

JNIEnv *jEnv,

jobject jThs,

jlong jCc,

jlong jNs,

jlong jCop,

jstring jAssocClass,

jstring jResultClass,

jstring jRole,

jstring jResultRole)

{

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

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

CIMClass *clsToBeCompared = DEBUG_ConvertJavaToC (jint, CIMClass*, jClsToBeCompared);

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

bool fRc = false;

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

CIMName assocClass;

if ( cls

if ( str

&& clsToBeCompared

&& *str

)

{

try

if (CIMName::legal (str))

{

fRc = cls->identical (*clsToBeCompared);

assocClass = str;

}

Catch (jEnv);

}

return fRc;

}

else

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1finalize

(JNIEnv *jEnv, jobject jThs, jint jCls)

{

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

jobject ev = jEnv->NewObject(

JMPIjvm::jv.CIMExceptionClassRef,

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF(

"Invalid association class name"));

delete cls;

jEnv->Throw ((jthrowable)ev);

DEBUG_ConvertCleanup (jint, jCls);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1filterProperties

jEnv->ReleaseStringUTFChars (jAssocClass,str);

(JNIEnv *jEnv, jobject jThs, jint jInst, jobjectArray jPl, jboolean iq, jboolean ic, jboolean lo)

{

CIMClass *cc = DEBUG_ConvertJavaToC (jint, CIMClass*, jInst);

CIMClass *cf = 0;

CIMName clsn = cc->getClassName ();

if (lo)

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

{

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

CIMName clsn = cc->getClassName ();

CIMName resultClass;

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

if ( str

&& *str

)

{

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

if (CIMName::legal (str))

cf->removeProperty (i);

{

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 DEBUG_ConvertCToJava (CIMClass*, jint, cf);

return 0;

}

else if (jPl)

{

CIMPropertyList pl = getList (jEnv,jPl);

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

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

jEnv->ReleaseStringUTFChars (jResultClass, str);

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

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

{

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

if (pos!= PEG_NOT_FOUND)

String role (str);

{

if (iq)

{

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

if (!ic)

jEnv->ReleaseStringUTFChars (jRole, str);

cp.setClassOrigin (CIMName ());

cf->addProperty (cp);

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

}

else

{

CIMProperty cp = cc->getProperty (pos);

CIMName co;

if (ic)

String resultRole (str);

co = cp.getClassOrigin ();

CIMProperty np (cp.getName (),

jEnv->ReleaseStringUTFChars (jResultRole, str);

cp.getValue (),

cp.getArraySize (),

cp.getReferenceClassName (),

co,

cp.getPropagated ());

cf->addProperty (np);

try {

}

checkNs (cop,jNs);

}

Array<CIMObjectPath> enm = cCc->associatorNames (cop->getNameSpace (),

if (iq)

*cop,

{

assocClass,

for (Uint32 i = 0, s = cc->getQualifierCount (); i < s; i++)

resultClass,

{

role,

cf->addQualifier (cc->getQualifier (i));

resultRole);

}

return DEBUG_ConvertCToJava(

Array<CIMObjectPath>*,

jlong,

new Array<CIMObjectPath> (enm));

}

Catch (jEnv);

return 0;

}

else if (iq)

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1associators(

JNIEnv *jEnv,

jobject jThs,

jlong jCc,

jlong jNs,

jlong jCop,

jstring jAssocClass,

jstring jResultClass,

jstring jRole,

jstring jResultRole,

jboolean includeQualifiers,

jboolean includeClassOrigin,

jobjectArray jPl)

{

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

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

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

CIMPropertyList pl = getList (jEnv, jPl);

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

if (ic)

CIMName assocClass;

return DEBUG_ConvertCToJava (CIMClass*, jint, cf);

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

if ( str

&& *str

)

{

CIMProperty cp = cf->getProperty (i);

if (CIMName::legal (str))

{

cp.setClassOrigin (CIMName ());

assocClass = str;

cf->removeProperty (i);

cf->addProperty (cp);

}

else

{

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

jobject ev = jEnv->NewObject(JMPIjvm::jv.CIMExceptionClassRef,

JMPIjvm::jv.CIMExceptionNewISt,

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

(jint)4, // CIM_ERR_INVALID_PARAMETER

{

jEnv->NewStringUTF(

CIMProperty cp = cc->getProperty (i);

"Invalid association class name"));

CIMName co;

if (ic)

co = cp.getClassOrigin ();

CIMProperty np (cp.getName (),

jEnv->Throw ((jthrowable)ev);

cp.getValue (),

cp.getArraySize (),

cp.getReferenceClassName (),

co,

cp.getPropagated ());

cf->addProperty (np);

return 0;

}

return DEBUG_ConvertCToJava (CIMClass*, jint, cf);

}

jEnv->ReleaseStringUTFChars (jAssocClass, str);

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

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

CIMName resultClass;

// ---

// - CIMInstance

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1new

if ( str

(JNIEnv *jEnv, jobject jThs)

&& *str

)

{

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

if (CIMName::legal (str))

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1newCn

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

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

resultClass = str;

CIMInstance *ci = new CIMInstance (CIMName (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->ReleaseStringUTFChars (jN,str);

jEnv->Throw ((jthrowable)ev);

return DEBUG_ConvertCToJava (CIMInstance*, jint, ci);

return 0;

}

//Added by Andy Viciu

jEnv->ReleaseStringUTFChars (jResultClass, str);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setName

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

{

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

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

jEnv->ReleaseStringUTFChars (jN,str);

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

/* NOT SUPPORTED AND NOT NEEDED*/

String role (str);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperty

jEnv->ReleaseStringUTFChars (jRole, str);

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

{

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

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

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

String resultRole (str);

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

Uint32 pos;

jEnv->ReleaseStringUTFChars (jResultRole, str);

if ( ci

&& cv

)

{

try {

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

checkNs (cop, jNs);

if (pos!= PEG_NOT_FOUND)

Array<CIMObject> enm = cCc->associators (cop->getNameSpace (),

{

*cop,

CIMProperty cp = ci->getProperty (pos);

assocClass,

resultClass,

role,

resultRole,

(Boolean)includeQualifiers,

(Boolean)includeClassOrigin,

pl);

Array<CIMInstance> *enmInst = new Array<CIMInstance> ();

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

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

{

cp.setValue (*cv);

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

}

else

{

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

throw CIMException (CIM_ERR_TYPE_MISMATCH, String ("Property type mismatch"));

}

Catch (jEnv);

ci->removeProperty (pos);

return 0;

ci->addProperty (cp);

}

else

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1referenceNames

(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop,

jstring jAssocClass, jstring jRole)

{

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

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

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

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

ci->addProperty (*cp);

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;

}

Catch (jEnv);

}

jEnv->ReleaseStringUTFChars (jN, str);

jEnv->ReleaseStringUTFChars (jAssocClass, str);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperties

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

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

{

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

if (!ci)

String role (str);

{

return;

}

try

jEnv->ReleaseStringUTFChars (jRole, str);

{

for (int i = 0, m = jEnv->CallIntMethod (jV,

JMPIjvm::jv.VectorSize);

i < m;

i++)

{

JMPIjvm::checkException (jEnv);

jobject jProp = jEnv->CallObjectMethod (jV,

try {

JMPIjvm::jv.VectorElementAt,

checkNs (cop, jNs);

i);

JMPIjvm::checkException (jEnv);

Array<CIMObjectPath> enm = cCc->referenceNames (cop->getNameSpace (),

*cop,

assocClass,

role);

jint jCpRef = jEnv->CallIntMethod (jProp, JMPIjvm::jv.CIMPropertyCInst);

return DEBUG_ConvertCToJava(

CIMProperty *cpNew = DEBUG_ConvertJavaToC (jint, CIMProperty*, jCpRef);

Array<CIMObjectPath>*,

jlong,

new Array<CIMObjectPath> (enm));

}

Catch (jEnv);

if (cpNew)

return 0;

{

}

Uint32 pos = ci->findProperty (cpNew->getName ());

if (pos != PEG_NOT_FOUND)

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1references

(JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop,

jstring jAssocClass, jstring jRole,

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)

{

CIMProperty cpOld = ci->getProperty (pos);

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

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

CIMPropertyList pl = getList (jEnv, jPl);

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

if (cpOld.getType () == cpNew->getType ())

CIMName assocClass;

if ( str

&& *str

)

{

ci->removeProperty (pos);

if (CIMName::legal (str))

ci->addProperty (*cpNew);

{

assocClass = str;

}

else

{

throw CIMException (CIM_ERR_TYPE_MISMATCH, String ("Property type mismatch"));

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;

}

Catch (jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperty

jEnv->ReleaseStringUTFChars (jAssocClass, str);

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

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

{

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

String role (str);

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

jint rv = 0;

jEnv->ReleaseStringUTFChars (jRole, str);

try {

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

checkNs (cop, jNs);

if (pos != PEG_NOT_FOUND)

Array<CIMObject> enm = cCc->references (cop->getNameSpace (),

{

*cop,

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

assocClass,

role,

(Boolean)includeQualifiers,

(Boolean)includeClassOrigin,

pl);

Array<CIMInstance> *enmInst = new Array<CIMInstance> ();

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

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

{

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

}

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

}

Catch (jEnv);

jEnv->ReleaseStringUTFChars (jN, str);

return 0;

return rv;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getKeyValuePairs

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createNameSpace

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

(JNIEnv *jEnv, jobject jThs, jlong jCc, jstring jNs)

{

JMPIjvm::cacheIDs (jEnv);

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

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

String ns (str);

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

jEnv->ReleaseStringUTFChars (jNs, str);

if ( ci

String lastNsComp;

&& CIMNamespaceName::legal (ci->getPath ().getNameSpace ().getString ())

String nsBase;

)

{

CIMOMHandle ch;

OperationContext oc;

CIMClass cc;

cc = ch.getClass (oc,

normalizeNs (ns, nsBase, lastNsComp);

ci->getPath ().getNameSpace (),

ci->getClassName (),

false, // localOnly

true, // includeQualifiers

true, // includeClassOrigin

CIMPropertyList ()); // propertyList

if (!cc.hasKeys ())

CIMInstance newInstance (CIMName ("__Namespace"));

{

newInstance.addProperty(CIMProperty(PEGASUS_PROPERTYNAME_NAME, lastNsComp));

return jVec;

try {

cCc->createInstance (CIMNamespaceName (nsBase), newInstance);

}

Catch (jEnv);

}

Array<CIMName> keyNames;

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateNameSpaces(

JNIEnv *jEnv,

jobject jThs,

jlong jCc,

jlong jCop,

jboolean deep,

jobject jVec)

{

JMPIjvm::cacheIDs (jEnv);

cc.getKeyNames (keyNames);

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

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

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

for (Uint32 i = 0; i < keyNames.size (); i++)

try {

{

Array<CIMObjectPath> enm = cCc->enumerateInstanceNames(

DDD(PEGASUS_STD (cout) << "finding key " << keyNames[i].getString () << PEGASUS_STD (endl));

cop->getNameSpace(),

CIMName("__Namespace"));

for (Uint32 j = 0; j < ci->getPropertyCount (); j++)

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

{

CIMProperty cp = ci->getProperty (j);

CIMObjectPath& cop = enm[i];

const Array<CIMKeyBinding>& kb = cop.getKeyBindings ();

const String& n = kb[0].getValue ();

if (cp.getName () == keyNames[i])

if (!deep && n.find ('/') != PEG_NOT_FOUND)

{

continue;

DDD(PEGASUS_STD (cout) << "adding key (" << j << ") " << keyNames[i].getString () << PEGASUS_STD (endl));

CIMProperty *cpRef = new CIMProperty (cp);

String x = ns+"/"+n;

jint jCpRef = DEBUG_ConvertCToJava (CIMProperty*, jint, cpRef);

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

jobject jProp = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,

JMPIjvm::jv.CIMPropertyNewI,

jCpRef);

jEnv->CallVoidMethod (jVec,

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

JMPIjvm::jv.VectorAddElement,

jProp);

}

Catch (jEnv);

return jVec;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMInstance__1getClassName

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteNameSpace

(JNIEnv *jEnv, jobject jThs, jint jInst)

(JNIEnv *jEnv, jobject jThs, jlong jCc, jstring jNs)

{

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

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

const String &cn = ci->getClassName ().getString ();

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

String ns (str);

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

jEnv->ReleaseStringUTFChars (jNs,str);

return str;

String lastNsComp;

}

String nsBase;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getQualifier

normalizeNs (ns,nsBase,lastNsComp);

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

CIMObjectPath cop (String::EMPTY,

CIMNamespaceName (nsBase),

CIMName ("__Namespace"));

Array<CIMKeyBinding> kb;

kb.append (CIMKeyBinding (PEGASUS_PROPERTYNAME_NAME,CIMValue (lastNsComp)));

cop.setKeyBindings (kb);

try {

cCc->deleteInstance (CIMNamespaceName (nsBase), cop);

}

Catch (jEnv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jCc)

{

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

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

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

jint rv = 0;

Uint32 pos;

if (ci)

delete cCc;

DEBUG_ConvertCleanup (jlong, jCc);

}

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

// ---

// - CIMDataType

// ---

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

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDataType__1new

(JNIEnv *jEnv, jobject jThs, jint type)

{

try

return DEBUG_ConvertCToJava (_dataType*, jlong, new _dataType (type));

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDataType__1newAr

(JNIEnv *jEnv, jobject jThs, jint type, jint size)

{

CIMOMHandle ch;

return DEBUG_ConvertCToJava (_dataType*, jlong, new _dataType (type,size));

OperationContext oc;

}

CIMClass cc;

cc = ch.getClass (oc,

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDataType__1newRef

ci->getPath ().getNameSpace (),

(JNIEnv *jEnv, jobject jThs, jint type, jstring jRef)

ci->getClassName (),

{

false, // localOnly

const char *ref = jEnv->GetStringUTFChars (jRef,NULL);

true, // includeQualifiers

jlong cInst = DEBUG_ConvertCToJava(

true, // includeClassOrigin

_dataType*,

CIMPropertyList ()); // propertyList

jlong,

new _dataType(type,String (ref)));

pos = cc.findQualifier (String (str));

jEnv->ReleaseStringUTFChars (jRef,ref);

if (pos != PEG_NOT_FOUND)

return cInst;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isReference

(JNIEnv *jEnv, jobject jThs, jlong jDt)

{

CIMQualifier *cq = 0;

_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);

cq = new CIMQualifier (cc.getQualifier (pos));

return dt->_reference == true;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isArray

(JNIEnv *jEnv, jobject jThs, jlong jDt)

{

_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);

rv = DEBUG_ConvertCToJava (CIMQualifier*, jint, cq);

return dt->_array == true;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getType

(JNIEnv *jEnv, jobject jThs, jlong jDt)

{

_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);

return dt->_type;

}

Catch (jEnv);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getSize

(JNIEnv *jEnv, jobject jThs, jlong jDt)

{

_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);

return dt->_size;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1getRefClassName

(JNIEnv *jEnv, jobject jThs, jlong jDt)

{

_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);

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

return str;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1toString

(JNIEnv *jEnv, jobject jThs, jlong jDt)

{

_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);

jstring str = NULL;

if (dt->_type & 0x10)

{

bool fSuccess = false;

String tmp = _dataType::convertJavaTypeToChars(dt->_type-0x10, &fSuccess);

if (!fSuccess)

return str;

tmp = tmp + "[]";

str = jEnv->NewStringUTF (tmp.getCString ());

}

else if (dt->_type == 0x20 + 1) // REFERENCE

{

String tmp = dt->_refClass + " REF";

str = jEnv->NewStringUTF (tmp.getCString ());

}

else

{

bool fSuccess = false;

char *tmp = _dataType::convertJavaTypeToChars (dt->_type, &fSuccess);

if (!fSuccess)

return str;

str = jEnv->NewStringUTF (tmp);

}

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDataType__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jDt)

{

_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);

delete dt;

DEBUG_ConvertCleanup (jlong, jDt);

}

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

// ---

// - CIMDateTime

// ---

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

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetime

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

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

CIMDateTime *dt = 0;

String date;

if ( str

&& *str

)

{

date = str;

}

jEnv->ReleaseStringUTFChars (jN, str);

try

{

dt = new CIMDateTime (date);

}

Catch (jEnv);

return DEBUG_ConvertCToJava (CIMDateTime*, jlong, dt);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetimeempty

(JNIEnv *jEnv, jobject jThs)

{

CIMDateTime *dt = new CIMDateTime (CIMDateTime::getCurrentDateTime ());

return DEBUG_ConvertCToJava (CIMDateTime*, jlong, dt);

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1after

(JNIEnv *jEnv, jobject jThs, jlong jC, jlong jD)

{

CIMDateTime *ct = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jC);

CIMDateTime *dt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jD);

jboolean rv = 0;

if ( ct

&& dt

)

{

rv = (jboolean)(ct->getDifference (*ct, *dt) < 0);

}

return rv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1clone

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1before

(JNIEnv *jEnv, jobject jThs, jint jInst)

(JNIEnv *jEnv, jobject jThs, jlong jC, jlong jD)

{

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

CIMDateTime *ct = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jC);

CIMInstance *cl = new CIMInstance (ci->clone ());

CIMDateTime *dt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jD);

jboolean rv = 0;

return DEBUG_ConvertCToJava (CIMInstance*, jint, cl);

if ( ct

&& dt

)

{

rv = (jboolean)(ct->getDifference (*ct, *dt) > 0);

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperties

return rv;

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

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDateTime__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jDT)

{

JMPIjvm::cacheIDs (jEnv);

CIMDateTime *cdt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jDT);

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

delete cdt;

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

DEBUG_ConvertCleanup (jlong, jDT);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDateTime__1getCIMString

(JNIEnv *jEnv, jobject jThs, jlong jDT)

{

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

CIMDateTime *cdt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jDT);

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

jstring jRet = 0;

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

if (cdt)

{

String dateString = cdt->toString ();

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

if (dateString.size () > 0)

{

jRet = jEnv->NewStringUTF (dateString.getCString ());

}

return jVec;

return jRet;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1finalize

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDateTime__1getMicroseconds

(JNIEnv *jEnv, jobject jThs, jint jInst)

(JNIEnv *jEnv, jobject jThs, jlong jDT)

{

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

CIMDateTime *cdt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jDT);

jlong jRet = 0;

delete ci;

if (cdt)

{

// Convert from 1 BCE epoch to POSIX 1970 microseconds

jRet = cdt->toMicroSeconds () - PEGASUS_UINT64_LITERAL(62167219200000000);

}

return jRet;

}

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

// ---

// - CIMInstance

// ---

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

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1new

(JNIEnv *jEnv, jobject jThs)

{

return DEBUG_ConvertCToJava (CIMInstance*, jlong, new CIMInstance ());

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1newCn

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

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

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

jEnv->ReleaseStringUTFChars (jN,str);

DEBUG_ConvertCleanup (jint, jInst);

return DEBUG_ConvertCToJava (CIMInstance*, jlong, ci);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1filterProperties

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1filterProperties(

(JNIEnv *jEnv, jobject jThs, jint jInst, jobjectArray jPl, jboolean iq, jboolean ic, jboolean lo)

JNIEnv *jEnv,

jobject jThs,

jlong jInst,

jobjectArray jPl,

jboolean iq,

jboolean ic,

jboolean lo)

{

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

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

CIMInstance *cf = 0;

CIMName clsn = ci->getClassName ();

Line 2538

Line 3533

cf->removeProperty (i);

}

return DEBUG_ConvertCToJava (CIMInstance*, jint, cf);

return DEBUG_ConvertCToJava (CIMInstance*, jlong, cf);

}

else if (jPl)

{

Line 2589

Line 3584

cf = new CIMInstance (ci->clone ());

if (ic)

return DEBUG_ConvertCToJava (CIMInstance*, jint, cf);

return DEBUG_ConvertCToJava (CIMInstance*, jlong, cf);

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

{

Line 2624

Line 3619

cf->setPath (ci->getPath ());

}

return DEBUG_ConvertCToJava (CIMInstance*, jint, cf);

return DEBUG_ConvertCToJava (CIMInstance*, jlong, cf);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setName

* Class: org_pegasus_jmpi_CIMInstance

(JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jN)

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

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

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

copRet = new CIMObjectPath (cop);

jEnv->ReleaseStringUTFChars (jN,str);

}

Catch (jEnv);

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, copRet);

/* NOT SUPPORTED AND NOT NEEDED*/

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperty

* Class: org_pegasus_jmpi_CIMInstance

(JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jN, jlong jV)

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

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

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

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

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

Uint32 pos;

try

{

if ( ci

&& cop

&& cv

)

{

ci->setPath (*cop);

try {

}

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

}

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 (pos != PEG_NOT_FOUND)

{

if (ci)

CIMProperty cp = ci->getProperty (pos);

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

{

ui32Ret = ci->getPropertyCount ();

cp.setValue (*cv);

}

else

{

throw CIMException(

CIM_ERR_TYPE_MISMATCH,

String ("Property type mismatch"));

}

Catch (jEnv);

return ui32Ret;

ci->removeProperty (pos);

ci->addProperty (cp);

}

else

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

CIMProperty *cpRet = NULL;

try

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

{

if (ci)

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

}

else

{

CIMProperty cp;

if (!cv->isArray ())

{

CIMObjectPath cop;

cp = ci->getProperty (ji);

cv->get (cop);

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

}

else

{

throwCIMException(

jEnv,

"+++ unsupported type in CIMProperty.property");

}

cpRet = new CIMProperty (cp);

ci->addProperty (*cp);

}

Catch (jEnv);

return DEBUG_ConvertCToJava (CIMProperty*, jint, cpRet);

}

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

jEnv->ReleaseStringUTFChars (jN, str);

// ---

}

// - CIMObjectPath

// ---

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

CIMObjectPath* construct ()

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperties

(JNIEnv *jEnv, jobject jThs, jlong jInst, jobject jV)

{

CIMObjectPath *cop = new CIMObjectPath ();

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

_nameSpace n;

cop->setNameSpace (n.nameSpace ());

cop->setHost (n.hostName ());

return cop;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1new

if (!ci)

(JNIEnv *jEnv, jobject jThs)

{

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, construct ());

return;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCn

try

(JNIEnv *jEnv, jobject jThs, jstring jCn)

{

CIMObjectPath *cop = construct ();

for (int i = 0, m = jEnv->CallIntMethod (jV,

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

JMPIjvm::jv.VectorSize);

i < m;

i++)

{

JMPIjvm::checkException (jEnv);

if (str)

jobject jProp = jEnv->CallObjectMethod (jV,

cop->setClassName (str);

JMPIjvm::jv.VectorElementAt,

i);

jEnv->ReleaseStringUTFChars (jCn, str);

JMPIjvm::checkException (jEnv);

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);

jlong jCpRef = jEnv->CallLongMethod(

}

jProp,

JMPIjvm::jv.CIMPropertyCInst);

CIMProperty *cpNew = DEBUG_ConvertJavaToC(

jlong,

CIMProperty*,

jCpRef);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCnNs

if (cpNew)

(JNIEnv *jEnv, jobject jThs, jstring jCn, jstring jNs)

{

CIMObjectPath *cop = construct ();

Uint32 pos = ci->findProperty (cpNew->getName ());

const char *str1 = NULL;

const char *str2 = NULL;

try {

if (pos != PEG_NOT_FOUND)

if (jCn)

{

str1 = jEnv->GetStringUTFChars (jCn, NULL);

CIMProperty cpOld = ci->getProperty (pos);

if (jNs)

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

if (cpOld.getType () == cpNew->getType ())

if (str1)

{

cop->setClassName (str1);

ci->removeProperty (pos);

if (str2)

ci->addProperty (*cpNew);

cop->setNameSpace (str2);

}

else

{

throw CIMException(

CIM_ERR_TYPE_MISMATCH,

String ("Property type mismatch"));

}

Catch (jEnv);

if (str1)

jEnv->ReleaseStringUTFChars (jCn, str1);

if (str2)

jEnv->ReleaseStringUTFChars (jNs, str2);

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCi

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperty

(JNIEnv *jEnv, jobject jThs, jint jInst)

(JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jN)

{

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

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

CIMObjectPath *cop = 0;

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

_nameSpace n;

jlong rv = 0;

try

try {

{

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

if (ci)

{

cop = new CIMObjectPath (ci->getPath ());

if (cop)

if (pos != PEG_NOT_FOUND)

{

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

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

cop->setNameSpace (n.nameSpace ());

if (cop->getHost ().size () == 0)

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

cop->setHost (n.hostName ());

}

Catch (jEnv);

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);

jEnv->ReleaseStringUTFChars (jN, str);

return rv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCiNs

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getKeyValuePairs

(JNIEnv *jEnv, jobject jThs, jint jInst, jstring jNamespace)

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

{

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

JMPIjvm::cacheIDs (jEnv);

CIMObjectPath *cop = 0;

const char *pszNamespace = jEnv->GetStringUTFChars (jNamespace, NULL);

CIMNamespaceName cnnNamespace;

bool fNamespaceValid = false;

_nameSpace n;

try

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

if ( ci

&& CIMNamespaceName::legal (ci->getPath ().getNameSpace ().getString ())

)

{

cnnNamespace = pszNamespace;

CIMOMHandle ch;

fNamespaceValid = true;

OperationContext oc;

}

CIMClass cc;

catch (Exception e)

cc = ch.getClass (oc,

ci->getPath ().getNameSpace (),

ci->getClassName (),

false, // localOnly

true, // includeQualifiers

true, // includeClassOrigin

CIMPropertyList ());// propertyList

if (!cc.hasKeys ())

{

return jVec;

}

jEnv->ReleaseStringUTFChars (jNamespace, pszNamespace);

Array<CIMName> keyNames;

try

cc.getKeyNames (keyNames);

{

if (ci)

{

cop = new CIMObjectPath (ci->getPath ());

if (cop)

for (Uint32 i = 0; i < keyNames.size (); i++)

{

if (fNamespaceValid)

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"finding key %s ",

(const char*)keyNames[i].getString().getCString()));

for (Uint32 j = 0; j < ci->getPropertyCount (); j++)

{

cop->setNameSpace (cnnNamespace);

CIMProperty cp = ci->getProperty (j);

}

else

if (cp.getName () == keyNames[i])

{

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

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

cop->setNameSpace (n.nameSpace ());

"adding key (%d) %s ",i,

}

(const char*)keyNames[i].getString().getCString()));

if (cop->getHost ().size () == 0)

CIMProperty *cpRef = new CIMProperty (cp);

cop->setHost (n.hostName ());

jlong jCpRef = DEBUG_ConvertCToJava (CIMProperty*, jlong, cpRef);

jobject jProp = jEnv->NewObject(

JMPIjvm::jv.CIMPropertyClassRef,

JMPIjvm::jv.CIMPropertyNewJ,

jCpRef);

jEnv->CallVoidMethod (jVec,

JMPIjvm::jv.VectorAddElement,

jProp);

}

Catch (jEnv);

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);

return jVec;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1finalize

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperties

(JNIEnv *jEnv, jobject jThs, jint jCop)

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

{

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

JMPIjvm::cacheIDs (jEnv);

delete cop;

DEBUG_ConvertCleanup (jint, jCop);

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

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getHost

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

(JNIEnv *jEnv, jobject jThs, jint jCop)

{

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

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

const String &hn = cop->getHost ();

jlong jCp = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp);

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

jobject prop = jEnv->NewObject(

JMPIjvm::jv.CIMPropertyClassRef,

JMPIjvm::jv.CIMPropertyNewJ,

jCp);

return str;

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

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setHost

return jVec;

(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jName)

{

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

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

cop->setHost (String (str));

jEnv->ReleaseStringUTFChars (jName,str);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getObjectName

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMInstance__1getClassName(

(JNIEnv *jEnv, jobject jThs, jint jCop)

JNIEnv *jEnv,

jobject jThs,

jlong jInst)

{

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

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

const String &cn = cop->getClassName ().getString ();

const String &cn = ci->getClassName ().getString ();

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

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setObjectName

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1getQualifier

(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jName)

(JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jN)

{

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

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

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

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

jlong rv = 0;

cop->setClassName (String (str));

Uint32 pos;

jEnv->ReleaseStringUTFChars (jName,str);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getNameSpace

if (ci)

(JNIEnv *jEnv, jobject jThs, jint jCop)

{

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

try

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

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

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setNameSpace

(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jName)

{

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

CIMOMHandle ch;

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

OperationContext oc;

CIMClass cc;

cop->setNameSpace (CIMNamespaceName (str));

jEnv->ReleaseStringUTFChars (jName,str);

cc = ch.getClass (oc,

}

ci->getPath ().getNameSpace (),

ci->getClassName (),

false, // localOnly

true, // includeQualifiers

true, // includeClassOrigin

CIMPropertyList ()); // propertyList

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1addKey

pos = cc.findQualifier (String (str));

(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jId, jint jVal)

if (pos != PEG_NOT_FOUND)

{

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

CIMQualifier *cq = 0;

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

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

Array<CIMKeyBinding> keyBindings = cop->getKeyBindings ();

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

cq = new CIMQualifier (cc.getQualifier (pos));

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

jEnv->ReleaseStringUTFChars (jId, str);

rv = DEBUG_ConvertCToJava (CIMQualifier*, jlong, cq);

}

Catch (jEnv);

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeys

jEnv->ReleaseStringUTFChars (jN, str);

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

{

JMPIjvm::cacheIDs (jEnv);

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

return rv;

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

}

for (Uint32 i = 0, s = akb.size (); i < s; i++)

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1clone

(JNIEnv *jEnv, jobject jThs, jlong jInst)

{

const String &n = akb[i].getName ().getString ();

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

const String &v = akb[i].getValue ();

CIMInstance *cl = new CIMInstance (ci->clone ());

CIMKeyBinding::Type t = akb[i].getType ();

CIMValue *cv = 0;

switch (t)

return DEBUG_ConvertCToJava (CIMInstance*, jlong, cl);

{

case CIMKeyBinding::NUMERIC:

cv = new CIMValue ((Sint32)atol (v.getCString ()));

break;

case CIMKeyBinding::STRING:

cv = new CIMValue (v);

break;

case CIMKeyBinding::BOOLEAN:

cv = new CIMValue ((Boolean) (v.getCString ()));

break;

case CIMKeyBinding::REFERENCE:

cv = new CIMValue (CIMObjectPath (akb[i].getValue ()));

break;

default:

throwCIMException (jEnv,"+++ unsupported type: ");

}

CIMProperty *cp = 0;

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jInst)

if (t != CIMKeyBinding::REFERENCE)

{

cp = new CIMProperty (n, *cv);

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

else

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

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

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

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

delete ci;

}

return jVec;

DEBUG_ConvertCleanup (jlong, jInst);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeyValue

(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jStr)

* Class: org_pegasus_jmpi_CIMInstance

* Method: _getObjectPath

* Signature: (I)I

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1getObjectPath

(JNIEnv *jEnv, jobject jThs, jlong jciCi)

{

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

CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciCi);

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

CIMObjectPath *copRet = NULL;

const char *strKeyName = jEnv->GetStringUTFChars (jStr,NULL);

jstring retStr = NULL;

for (Uint32 i = 0,s = akb.size (); i<s; i++)

try

{

const String &n = akb[i].getName ().getString ();

if (ci)

if (n == String (strKeyName))

{

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

const CIMObjectPath& cop = ci->getPath ();

break;

copRet = new CIMObjectPath (cop);

}

Catch (jEnv);

jEnv->ReleaseStringUTFChars (jStr,strKeyName);

return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, copRet);

return retStr;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1set

(JNIEnv *jEnv, jobject jThs, jstring jStr)

* Class: org_pegasus_jmpi_CIMInstance

* Method: _setObjectPath

* Signature: (II)V

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setObjectPath

(JNIEnv *jEnv, jobject jThs, jlong jciCi, jlong jciCop)

{

const char *strCop = jEnv->GetStringUTFChars (jStr,NULL);

CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciCi);

CIMObjectPath *cop = new CIMObjectPath ();

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jciCop);

cop->set (String (strCop));

jEnv->ReleaseStringUTFChars (jStr,strCop);

try

{

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);

if ( ci

&& cop

)

{

ci->setPath (*cop);

}

Catch (jEnv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setKeys

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

* Class: org_pegasus_jmpi_CIMInstance

* Method: _getPropertyCount

* Signature: (I)I

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getPropertyCount

(JNIEnv *jEnv, jobject jThs, jlong jciCi)

{

JMPIjvm::cacheIDs (jEnv);

CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciCi);

Uint32 ui32Ret = 0;

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

Array<CIMKeyBinding> akb;

for (Uint32 i = 0, s = jEnv->CallIntMethod (jVec,JMPIjvm::jv.VectorSize); i < s; i++)

try

{

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

if (ci)

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

{

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

ui32Ret = ci->getPropertyCount ();

}

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

}

Catch (jEnv);

cop->setKeyBindings (akb);

return ui32Ret;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1clone

(JNIEnv *jEnv, jobject jThs, jint jCop)

* Class: org_pegasus_jmpi_CIMInstance

* Method: _getProperty

* Signature: (II)I

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1getPropertyI

(JNIEnv *jEnv, jobject jThs, jlong jciCi, jint ji)

{

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

CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jciCi);

CIMObjectPath *copl = new CIMObjectPath (cop->getHost (), cop->getNameSpace (), cop->getClassName (), cop->getKeyBindings ());

CIMProperty *cpRet = NULL;

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, copl);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1toString

try

(JNIEnv *jEnv, jobject jThs, jint jCop)

{

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

if (ci)

const String &ns = cop->toString ();

{

CIMProperty cp;

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

cp = ci->getProperty (ji);

return str;

cpRet = new CIMProperty (cp);

}

Catch (jEnv);

return DEBUG_ConvertCToJava (CIMProperty*, jlong, cpRet);

}

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

// ---

// - CIMDataType

// - CIMMethod

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1new

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1getType

(JNIEnv *jEnv, jobject jThs, jint type)

(JNIEnv *jEnv, jobject jThs, jlong jM)

{

return DEBUG_ConvertCToJava (_dataType*, jint, new _dataType (type));

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newAr

(JNIEnv *jEnv, jobject jThs, jint type, jint size)

{

return DEBUG_ConvertCToJava (_dataType*, jint, new _dataType (type,size));

CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);

}

bool fSuccess = false;

jint jType = 0;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newRef

if (cm)

(JNIEnv *jEnv, jobject jThs, jint type, jstring jRef)

{

const char *ref = jEnv->GetStringUTFChars (jRef,NULL);

CIMType ct = cm->getType ();

jint cInst = DEBUG_ConvertCToJava (_dataType*, jint, new _dataType (type,String (ref)));

jEnv->ReleaseStringUTFChars (jRef,ref);

jType = _dataType::convertCTypeToJavaType (ct, &fSuccess);

}

return cInst;

return jType;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isArray

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMMethod__1getName

(JNIEnv *jEnv, jobject jThs, jint jDt)

(JNIEnv *jEnv, jobject jThs, jlong jM)

{

_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);

CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);

jstring str = 0;

return dt->_array == true;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isReference

if (cm)

(JNIEnv *jEnv, jobject jThs, jint jDt)

{

_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);

CIMName cn = cm->getName ();

return dt->_reference == true;

str = jEnv->NewStringUTF (cn.getString ().getCString ());

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getType

return str;

(JNIEnv *jEnv, jobject jThs, jint jDt)

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1findParameter

(JNIEnv *jEnv, jobject jThs, jlong jM, jstring jName)

{

_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);

CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);

jint rv = -1;

return dt->_type;

if (cm && jName)

}

{

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getSize

try

(JNIEnv *jEnv, jobject jThs, jint jDt)

{

_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);

CIMName name (cstrName);

return dt->_size;

rv = cm->findParameter (name);

}

Catch (jEnv);

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1getRefClassName

jEnv->ReleaseStringUTFChars (jName, cstrName);

(JNIEnv *jEnv, jobject jThs, jint jDt)

}

{

_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);

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

return str;

return rv;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1toString

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMMethod__1getParameter

(JNIEnv *jEnv, jobject jThs, jint jDt)

(JNIEnv *jEnv, jobject jThs, jlong jM, jint jParameter)

{

_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);

CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);

jstring str = NULL;

jlong rv = 0;

if (dt->_type & 0x10)

if (cm && jParameter >= 0)

{

bool fSuccess = false;

try

String tmp = _dataType::convertJavaTypeToChars (dt->_type-0x10, &fSuccess);

{

CIMParameter cp = cm->getParameter (jParameter);

if (!fSuccess)

return str;

tmp = tmp + "[]";

str = jEnv->NewStringUTF (tmp.getCString ());

rv = DEBUG_ConvertCToJava(CIMParameter *, jlong, new CIMParameter(cp));

}

Catch (jEnv);

}

else if (dt->_type == 0x20 + 1) // REFERENCE

{

String tmp = dt->_refClass + " REF";

str = jEnv->NewStringUTF (tmp.getCString ());

return rv;

}

else

{

bool fSuccess = false;

char *tmp = _dataType::convertJavaTypeToChars (dt->_type, &fSuccess);

if (!fSuccess)

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1getParameterCount

return str;

(JNIEnv *jEnv, jobject jThs, jlong jM)

{

CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);

jint rv = 0;

str = jEnv->NewStringUTF (tmp);

if (cm)

{

try

{

rv = cm->getParameterCount ();

}

Catch (jEnv);

}

return str;

return rv;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDataType__1finalize

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize

(JNIEnv *jEnv, jobject jThs, jint jDt)

(JNIEnv *jEnv, jobject jThs, jlong jM)

{

_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);

CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);

delete dt;

delete cm;

DEBUG_ConvertCleanup (jint, jDt);

DEBUG_ConvertCleanup (jlong, jM);

}

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

// ---

// - CIMArgument

// - CIMNameSpace

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1getValue

_nameSpace::_nameSpace ()

(JNIEnv *jEnv, jobject jThs, jint jP)

{

CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP);

port_ = 0;

CIMValue *cv = new CIMValue (cp->getValue ());

hostName_ = System::getHostName ();

nameSpace_ = "root/cimv2";

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

fHttps = false;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1new

_nameSpace::_nameSpace (String hn)

(JNIEnv *jEnv, jobject jThs)

{

CIMParamValue *p = new CIMParamValue (String::EMPTY,CIMValue ());

port_ = 0;

hostName_ = hn;

nameSpace_ = "root/cimv2";

fHttps = false;

}

return DEBUG_ConvertCToJava (CIMParamValue*, jint, p);

_nameSpace::_nameSpace (String hn, String ns)

{

port_ = 0;

hostName_ = hn;

nameSpace_ = ns;

fHttps = false;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1newS

int _nameSpace::port ()

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

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

if (port_)

CIMParamValue *p = new CIMParamValue (str, CIMValue ());

return port_;

jEnv->ReleaseStringUTFChars (jN, str);

port_ = 5988;

return DEBUG_ConvertCToJava (CIMParamValue*, jint, p);

if (hostName_.subString (0,7) == "http://")

{

protocol_ = hostName_.subString (0,7);

hostName_ = hostName_.subString (7);

}

else if (hostName_.subString (0,8) == "https://")

{

protocol_ = hostName_.subString (0,8);

hostName_ = hostName_.subString (8);

fHttps = true;

}

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1newSV

if (p >= 0)

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

{

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

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

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

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

CIMParamValue *p = 0;

if ( str

hostName_.remove (p);

&& cv

}

)

return port_;

}

String _nameSpace::hostName ()

{

p = new CIMParamValue (str, *cv);

port ();

return hostName_;

}

jEnv->ReleaseStringUTFChars (jN, str);

String _nameSpace::nameSpace ()

{

return nameSpace_;

}

Boolean _nameSpace::isHttps ()

{

port ();

return fHttps;

}

return DEBUG_ConvertCToJava (CIMParamValue*, jint, p);

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1new

(JNIEnv *jEnv, jobject jThs)

{

return DEBUG_ConvertCToJava (_nameSpace*, jlong, new _nameSpace ());

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setValue

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHn

(JNIEnv *jEnv, jobject jThs, jint jP,jint jV)

(JNIEnv *jEnv, jobject jThs, jstring jHn)

{

CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP);

const char *hn = jEnv->GetStringUTFChars (jHn, NULL);

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

jlong cInst = DEBUG_ConvertCToJava(_nameSpace*, jlong, new _nameSpace(hn));

cp->setValue (*cv);

jEnv->ReleaseStringUTFChars (jHn, hn);

return cInst;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMArgument__1getName

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHnNs

(JNIEnv *jEnv, jobject jThs, jint jP)

(JNIEnv *jEnv, jobject jThs, jstring jHn, jstring jNs)

{

CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP);

const char *hn = jEnv->GetStringUTFChars (jHn, NULL);

const String &n = cp->getParameterName ();

const char *ns = jEnv->GetStringUTFChars (jNs, NULL);

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

jlong cInst = DEBUG_ConvertCToJava(

_nameSpace*,

jlong,

new _nameSpace(String (hn),String (ns)));

jEnv->ReleaseStringUTFChars (jHn, hn);

jEnv->ReleaseStringUTFChars (jNs, ns);

return cInst;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getNameSpace

(JNIEnv *jEnv, jobject jThs, jlong jNs)

{

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

const String &ns = cNs->nameSpace_;

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

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setName

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getHost

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

(JNIEnv *jEnv, jobject jThs, jlong jNs)

{

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

const String &hn = cNs->hostName_;

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

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setNameSpace

(JNIEnv *jEnv, jobject jThs, jlong jNs, jstring jN)

{

CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP);

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

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

String n (str);

cp->setParameterName (n);

cNs->nameSpace_ = str;

jEnv->ReleaseStringUTFChars (jN, str);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1getType

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setHost

(JNIEnv *jEnv, jobject jThs, jint jP)

(JNIEnv *jEnv, jobject jThs, jlong jNs, jstring jHn)

{

CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP);

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

const CIMValue cv = cp->getValue ();

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

String ref;

bool fSuccess = false;

int iJType = 0;

_dataType *type = 0;

iJType = _dataType::convertCTypeToJavaType (cv.getType (), &fSuccess);

cNs->port_ = 0;

cNs->hostName_ = str;

if (fSuccess)

jEnv->ReleaseStringUTFChars (jHn, str);

{

type = new _dataType (iJType,

cv.getArraySize (),

false,

cv.isArray (),

ref,

true);

}

return DEBUG_ConvertCToJava (_dataType*, jint, type);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jNs)

{

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

delete cNs;

DEBUG_ConvertCleanup (jlong, jNs);

}

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

// ---

// - CIMProperty

// - CIMObject

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getValue

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObject__1newClass

(JNIEnv *jEnv, jobject jThs, jint jP)

(JNIEnv *jEnv, jobject jThs, jlong jCc)

{

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

CIMClass *cCc = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCc);

CIMValue *cv = new CIMValue (cp->getValue ());

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

try {

}

CIMObject *cCo = new CIMObject (*cCc);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1new

return DEBUG_ConvertCToJava (CIMObject*, jlong, cCo);

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

}

{

Catch (jEnv);

CIMProperty *p = new CIMProperty (CIMName (),CIMValue ());

return DEBUG_ConvertCToJava (CIMProperty*, jint, p);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1property

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObject__1newInstance

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

(JNIEnv *jEnv, jobject jThs, jlong jCi)

{

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

CIMInstance *cCi = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jCi);

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

CIMProperty *cp = 0;

jint jCp = 0;

try {

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

CIMObject *cCo = new CIMObject (*cCi);

{

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

return DEBUG_ConvertCToJava (CIMObject*, jlong, cCo);

}

else

Catch (jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObject__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jInst)

{

if (!cv->isArray ())

CIMObject *co = DEBUG_ConvertJavaToC (jlong, CIMObject*, jInst);

delete co;

DEBUG_ConvertCleanup (jlong, jInst);

}

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

// ---

// - CIMObjectPath

// ---

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

CIMObjectPath* construct ()

{

CIMObjectPath cop;

CIMObjectPath *cop = new CIMObjectPath ();

_nameSpace n;

cv->get (cop);

cop->setNameSpace (n.nameSpace ());

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

cop->setHost (n.hostName ());

return cop;

}

else

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1new

(JNIEnv *jEnv, jobject jThs)

{

throwCIMException (jEnv,"+++ unsupported type in CIMProperty.property");

return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, construct ());

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCn

(JNIEnv *jEnv, jobject jThs, jstring jCn)

{

CIMObjectPath *cop = construct ();

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

if (str)

cop->setClassName (str);

jEnv->ReleaseStringUTFChars (jCn, str);

return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);

}

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

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCnNs

(JNIEnv *jEnv, jobject jThs, jstring jCn, jstring jNs)

{

CIMObjectPath *cop = construct ();

const char *str1 = NULL;

const char *str2 = NULL;

try {

if (jCn)

str1 = jEnv->GetStringUTFChars (jCn, NULL);

if (jNs)

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

if (str1)

cop->setClassName (str1);

if (str2)

cop->setNameSpace (str2);

}

Catch (jEnv);

jEnv->ReleaseStringUTFChars (jN, str);

if (str1)

jEnv->ReleaseStringUTFChars (jCn, str1);

if (str2)

jEnv->ReleaseStringUTFChars (jNs, str2);

return jCp;

return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setValue

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCi

(JNIEnv *jEnv, jobject jThs, jint jP,jint jV)

(JNIEnv *jEnv, jobject jThs, jlong jInst)

{

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

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

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

CIMObjectPath *cop = 0;

_nameSpace n;

cp->setValue (*cv);

try

}

{

if (ci)

{

cop = new CIMObjectPath (ci->getPath ());

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isArray

if (cop)

(JNIEnv *jEnv, jobject jThs, jint jP)

{

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

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

cop->setNameSpace (n.nameSpace ());

return (jboolean)cp->isArray ();

if (cop->getHost ().size () == 0)

cop->setHost (n.hostName ());

}

Catch (jEnv);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addValue

return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);

(JNIEnv *jEnv, jobject jThs, jint jP, jint jV)

}

{

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

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

CIMValue cv = cp->getValue ();

if (cvin->isNull ())

throwCIMException (jEnv,"+++ null cvin value ");

if (!cv.isArray ())

throwCIMException (jEnv,"+++ not an array ");

if (cvin->getType ()!= cv.getType ())

throwCIMException (jEnv,"+++ type mismatch ");

CIMType type = cv.getType ();

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCiNs

(JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jNamespace)

{

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

CIMObjectPath *cop = 0;

const char *pszNamespace = jEnv->GetStringUTFChars (jNamespace, NULL);

CIMNamespaceName cnnNamespace;

bool fNamespaceValid = false;

_nameSpace n;

switch (type)

try

{

case CIMTYPE_BOOLEAN:

cnnNamespace = pszNamespace;

fNamespaceValid = true;

}

catch (Exception e)

{

Boolean bo;

cvin->get (bo);

Array<Boolean> boarr;

cv.get (boarr);

boarr.append (bo);

cv.set (boarr);

break;

}

case CIMTYPE_UINT8:

jEnv->ReleaseStringUTFChars (jNamespace, pszNamespace);

try

{

Uint8 u8;

if (ci)

cvin->get (u8);

Array<Uint8> u8arr;

cv.get (u8arr);

u8arr.append (u8);

cv.set (u8arr);

break;

}

case CIMTYPE_SINT8:

{

Sint8 s8;

cvin->get (s8);

Array<Sint8> s8arr;

cv.get (s8arr);

s8arr.append (s8);

cv.set (s8arr);

break;

}

case CIMTYPE_UINT16:

{

Uint16 u16;

cvin->get (u16);

Array<Uint16> u16arr;

cv.get (u16arr);

u16arr.append (u16);

cv.set (u16arr);

break;

}

case CIMTYPE_SINT16:

{

Sint16 s16;

cvin->get (s16);

Array<Sint16> s16arr;

cv.get (s16arr);

s16arr.append (s16);

cv.set (s16arr);

break;

}

case CIMTYPE_UINT32:

{

Uint32 u32;

cvin->get (u32);

Array<Uint32> u32arr;

cv.get (u32arr);

u32arr.append (u32);

cv.set (u32arr);

break;

}

case CIMTYPE_SINT32:

{

Sint32 s32;

cvin->get (s32);

Array<Sint32> s32arr;

cv.get (s32arr);

s32arr.append (s32);

cv.set (s32arr);

break;

}

case CIMTYPE_UINT64:

{

Uint64 u64;

cvin->get (u64);

Array<Uint64> u64arr;

cv.get (u64arr);

u64arr.append (u64);

cv.set (u64arr);

break;

}

case CIMTYPE_SINT64:

{

Sint64 s64;

cvin->get (s64);

Array<Sint64> s64arr;

cv.get (s64arr);

s64arr.append (s64);

cv.set (s64arr);

break;

}

case CIMTYPE_REAL32:

{

Real32 f;

cvin->get (f);

Array<Real32> farr;

cv.get (farr);

farr.append (f);

cv.set (farr);

break;

}

case CIMTYPE_REAL64:

{

Real64 d;

cvin->get (d);

Array<Real64> darr;

cv.get (darr);

darr.append (d);

cv.set (darr);

break;

}

case CIMTYPE_CHAR16:

{

Char16 c16;

cop = new CIMObjectPath (ci->getPath ());

cvin->get (c16);

Array<Char16> c16arr;

if (cop)

cv.get (c16arr);

c16arr.append (c16);

cv.set (c16arr);

break;

}

case CIMTYPE_STRING:

{

String str;

if (fNamespaceValid)

cvin->get (str);

Array<String> strarr;

cv.get (strarr);

strarr.append (str);

cv.set (strarr);

break;

}

case CIMTYPE_DATETIME:

{

CIMDateTime dt;

cop->setNameSpace (cnnNamespace);

cvin->get (dt);

Array<CIMDateTime> dtarr;

cv.get (dtarr);

dtarr.append (dt);

cv.set (dtarr);

break;

}

case CIMTYPE_REFERENCE:

else

{

CIMObjectPath ref;

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

cvin->get (ref);

cop->setNameSpace (n.nameSpace ());

Array<CIMObjectPath> refarr;

cv.get (refarr);

refarr.append (ref);

cv.set (refarr);

break;

}

case CIMTYPE_OBJECT:

{

if (cop->getHost ().size () == 0)

CIMObject obj;

cop->setHost (n.hostName ());

cvin->get (obj);

Array<CIMObject> objarr;

cv.get (objarr);

objarr.append (obj);

cv.set (objarr);

break;

}

default:

{

throwCIMException (jEnv,"+++ unsupported type ");

}

Catch (jEnv);

cp->setValue (cv);

return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addQualifier

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1finalize

(JNIEnv *jEnv, jobject jThs, jint jP, jint jQ)

(JNIEnv *jEnv, jobject jThs, jlong jCop)

{

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

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

CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);

cp->addQualifier (*cq);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getName

delete cop;

(JNIEnv *jEnv, jobject jThs, jint jP)

{

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

const String &n = cp->getName ().getString ();

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

return str;

DEBUG_ConvertCleanup (jlong, jCop);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setName

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getNameSpace

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

(JNIEnv *jEnv, jobject jThs, jlong jCop)

{

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

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

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

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

cp->setName (CIMName (str));

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

jEnv->ReleaseStringUTFChars (jN,str);

return str;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isReference

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setNameSpace

(JNIEnv *jEnv, jobject jThs, jint jP)

(JNIEnv *jEnv, jobject jThs, jlong jCop, jstring jName)

{

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

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

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

return (jboolean) (cp->getType () == CIMTYPE_REFERENCE);

cop->setNameSpace (CIMNamespaceName (str));

jEnv->ReleaseStringUTFChars (jName,str);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getRefClassName

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getHost

(JNIEnv *jEnv, jobject jThs, jint jP)

(JNIEnv *jEnv, jobject jThs, jlong jCop)

{

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

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

const String &n = cp->getReferenceClassName ().getString ();

const String &hn = cop->getHost ();

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

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

return str;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getType

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setHost

(JNIEnv *jEnv, jobject jThs, jint jP)

(JNIEnv *jEnv, jobject jThs, jlong jCop, jstring jName)

{

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

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

String ref = cp->getReferenceClassName ().getString ();

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

bool fSuccess = false;

int iJType = 0;

_dataType *type = 0;

iJType = _dataType::convertCTypeToJavaType (cp->getType (), &fSuccess);

if (fSuccess)

cop->setHost (String (str));

{

type = new _dataType (iJType,

cp->getArraySize (),

ref.size () ? true : false,

false,

cp->isArray (),

ref,

true);

}

return DEBUG_ConvertCToJava (_dataType*, jint, type);

jEnv->ReleaseStringUTFChars (jName,str);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1setType

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getObjectName

(JNIEnv *jEnv, jobject jThs, jint jP, jint jDt)

(JNIEnv *jEnv, jobject jThs, jlong jCop)

{

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

_dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);

CIMValue val;

bool fSuccess = false;

CIMType cType = CIMTYPE_BOOLEAN;

cType = _dataType::convertJavaTypeToCType (dt->_type, &fSuccess);

if (fSuccess)

{

val.setNullValue (cType, dt->_array);

CIMProperty *np = new CIMProperty (cp->getName (), val);

delete cp;

DEBUG_ConvertCleanup (jint, jP);

return DEBUG_ConvertCToJava (CIMProperty*, jint, np);

}

else

{

return DEBUG_ConvertCToJava (CIMProperty*, jint, cp);

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

}

const String &cn = cop->getClassName ().getString ();

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMProperty__1getIdentifier

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

(JNIEnv *jEnv, jobject jThs, jint jP)

{

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

const String &n = cp->getName ().getString ();

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

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1finalize

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setObjectName

(JNIEnv *jEnv, jobject jThs, jint jP)

(JNIEnv *jEnv, jobject jThs, jlong jCop, jstring jName)

{

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

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

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

delete cp;

cop->setClassName (String (str));

DEBUG_ConvertCleanup (jint, jP);

jEnv->ReleaseStringUTFChars (jName,str);

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeys

* Class: org_pegasus_jmpi_CIMProperty

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

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

JMPIjvm::cacheIDs (jEnv);

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

Uint32 index = PEG_NOT_FOUND;

try

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

{

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

index = cp->findQualifier (CIMName (str));

jEnv->ReleaseStringUTFChars (jQualifier, str);

for (Uint32 i = 0, s = akb.size (); i < s; i++)

}

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

const String &n = akb[i].getName ().getString ();

CIMQualifier *cq = NULL;

const String &v = akb[i].getValue ();

CIMQualifier qualifier;

CIMKeyBinding::Type t = akb[i].getType ();

CIMValue *cv = 0;

try

switch (t)

{

qualifier = cp->getQualifier ((Uint32)jIndex);

case CIMKeyBinding::NUMERIC:

cq = new CIMQualifier (qualifier);

cv = new CIMValue ((Sint32)atol (v.getCString ()));

}

break;

Catch (jEnv);

case CIMKeyBinding::STRING:

cv = new CIMValue (v);

return DEBUG_ConvertCToJava (CIMQualifier *, jint, cq);

break;

case CIMKeyBinding::BOOLEAN:

cv = new CIMValue ((Boolean) (v.getCString ()));

break;

case CIMKeyBinding::REFERENCE:

cv = new CIMValue (CIMObjectPath (akb[i].getValue ()));

break;

default:

throwCIMException (jEnv,"+++ unsupported type: ");

}

CIMProperty *cp = 0;

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

if (t != CIMKeyBinding::REFERENCE)

// ---

cp = new CIMProperty (n, *cv);

// - CIMQualifierType

else

// ---

cp = new CIMProperty(

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

*cv,

((CIMObjectPath) akb[i].getValue()).getClassName());

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1new

jlong jCp = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp);

(JNIEnv *jEnv, jobject jThs)

jobject prop = jEnv->NewObject(

{

JMPIjvm::jv.CIMPropertyClassRef,

CIMQualifierDecl *qual = new CIMQualifierDecl ();

JMPIjvm::jv.CIMPropertyNewJ,

jCp);

return DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, qual);

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

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1finalize

return jVec;

(JNIEnv *jEnv, jobject jThs, jint jQ)

{

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

delete qt;

DEBUG_ConvertCleanup (jint, jQ);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1getName

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setKeys

(JNIEnv *jEnv, jobject jThs, jint jQ)

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

{

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

JMPIjvm::cacheIDs (jEnv);

const String &n = qt->getName ().getString ();

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

return str;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setName

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

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

Array<CIMKeyBinding> akb;

{

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

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

jint jret = 0;

if (qt->isUninitialized ())

for (Uint32 i=0,s=jEnv->CallIntMethod(jVec,JMPIjvm::jv.VectorSize);i<s;i++)

{

CIMQualifierDecl *nqt = new CIMQualifierDecl (CIMName (str), CIMValue (), CIMScope ());

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

jlong jCp = jEnv->CallLongMethod (o,JMPIjvm::jv.CIMPropertyCInst);

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jCp);

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

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

}

else

{

qt->setName (CIMName (str));

CIMQualifierDecl *nqt = new CIMQualifierDecl (*qt);

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

cop->setKeyBindings (akb);

}

jEnv->ReleaseStringUTFChars (jN, str);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1addKey

(JNIEnv *jEnv, jobject jThs, jlong jCop, jstring jId, jlong jVal)

{

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

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

CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jVal);

Array<CIMKeyBinding> keyBindings = cop->getKeyBindings ();

return jret;

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

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

jEnv->ReleaseStringUTFChars (jId, str);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setValue

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeyValue

(JNIEnv *jEnv, jobject jThs, jint jQ,jint jV)

(JNIEnv *jEnv, jobject jThs, jlong jCop, jstring jStr)

{

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

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

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

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

const char *strKeyName = jEnv->GetStringUTFChars (jStr,NULL);

qt->setValue (*cv);

jstring retStr = NULL;

}

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

for (Uint32 i = 0,s = akb.size (); i<s; i++)

// ---

{

// - CIMQualifier

const String &n = akb[i].getName ().getString ();

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifier__1new

if (n == String (strKeyName))

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

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

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

CIMQualifier *qual = new CIMQualifier (CIMName (str),CIMValue ());

break;

}

jEnv->ReleaseStringUTFChars (jN,str);

jEnv->ReleaseStringUTFChars (jStr,strKeyName);

return DEBUG_ConvertCToJava (CIMQualifier*, jint, qual);

return retStr;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1finalize

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1toString

(JNIEnv *jEnv, jobject jThs, jint jQ)

(JNIEnv *jEnv, jobject jThs, jlong jCop)

{

CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);

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

const String &ns = cop->toString ();

delete cq;

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

DEBUG_ConvertCleanup (jint, jQ);

return str;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getName

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1clone

(JNIEnv *jEnv, jobject jThs, jint jQ)

(JNIEnv *jEnv, jobject jThs, jlong jCop)

{

CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);

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

const String &n = cq->getName ().getString ();

CIMObjectPath *copl = new CIMObjectPath(

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

cop->getHost(),

cop->getNameSpace(),

cop->getClassName(),

cop->getKeyBindings());

return str;

return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, copl);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getValue

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1set

(JNIEnv *jEnv, jobject jThs, jint jQ)

(JNIEnv *jEnv, jobject jThs, jstring jStr)

{

CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);

const char *strCop = jEnv->GetStringUTFChars (jStr,NULL);

CIMValue *cv = new CIMValue (cq->getValue ());

CIMObjectPath *cop = new CIMObjectPath ();

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

cop->set (String (strCop));

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1setValue

jEnv->ReleaseStringUTFChars (jStr,strCop);

(JNIEnv *jEnv, jobject jThs, jint jQ,jint jV)

{

CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);

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

cq->setValue (*cv);

return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);

}

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

// ---

// - CIMDateTime

// - CIMOMHandle

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetime

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getClass

(JNIEnv *jEnv, jobject jThs, jstring jN)

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

jboolean iq, jboolean ic, jobjectArray jPl)

{

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

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

CIMDateTime *dt = 0;

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

String date;

CIMPropertyList pl;

OperationContext ctx;

if ( str

if (jPl)

&& *str

pl = getList (jEnv, jPl);

)

else

{

pl = CIMPropertyList ();

date = str;

}

jEnv->ReleaseStringUTFChars (jN, str);

try {

CIMClass cls = ch->getClass (ctx,

cop->getNameSpace (),

cop->getClassName (),

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,

pl);

try

return DEBUG_ConvertCToJava (CIMClass*, jlong, new CIMClass (cls));

{

dt = new CIMDateTime (date);

}

Catch (jEnv);

return DEBUG_ConvertCToJava (CIMDateTime*, jint, dt);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetimeempty

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteClass

(JNIEnv *jEnv, jobject jThs)

(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop)

{

CIMDateTime *dt = new CIMDateTime (CIMDateTime::getCurrentDateTime ());

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

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

OperationContext ctx;

return DEBUG_ConvertCToJava (CIMDateTime*, jint, dt);

try {

ch->deleteClass (ctx,

cop->getNameSpace (),

cop->getClassName ());

}

Catch(jEnv);

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1after

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createClass

(JNIEnv *jEnv, jobject jThs, jint jC, jint jD)

(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jlong jCl)

{

CIMDateTime *ct = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jC);

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

CIMDateTime *dt = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jD);

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

jboolean ret = 0;

CIMClass *cl = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCl);

OperationContext ctx;

if ( ct

try {

&& dt

ch->createClass (ctx,

)

cop->getNameSpace (),

{

*cl);

ret = (jboolean)(ct->getDifference (*ct, *dt) < 0);

}

Catch(jEnv);

return ret;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1before

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setClass

(JNIEnv *jEnv, jobject jThs, jint jC, jint jD)

(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jlong jCl)

{

CIMDateTime *ct = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jC);

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

CIMDateTime *dt = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jD);

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

jboolean ret = 0;

CIMClass *cl = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCl);

OperationContext ctx;

if ( ct

try {

&& dt

ch->modifyClass (ctx,

)

cop->getNameSpace (),

{

*cl);

ret = (jboolean)(ct->getDifference (*ct, *dt) > 0);

}

Catch(jEnv);

return ret;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDateTime__1finalize

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClassNames

(JNIEnv *jEnv, jobject jThs, jint jDT)

(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jboolean deep)

{

CIMDateTime *cdt = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jDT);

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

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

CIMNamespaceName ns = cop->getNameSpace ();

OperationContext ctx;

delete cdt;

try {

Array<CIMName> enm = ch->enumerateClassNames(ctx,

cop->getNameSpace(),

cop->getClassName(),

(Boolean)deep);

Array<CIMObjectPath> *enmop = new Array<CIMObjectPath> ();

DEBUG_ConvertCleanup (jint, jDT);

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

{

enmop->append (CIMObjectPath (String::EMPTY,

ns,

enm[i]));

}

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

return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jlong, enmop);

// ---

}

// - CIMMethod

Catch(jEnv);

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1getType

return 0;

(JNIEnv *jEnv, jobject jThs, jint jM)

}

{

CIMMethod *cm = DEBUG_ConvertJavaToC (jint, CIMMethod*, jM);

bool fSuccess = false;

int iJType = 0;

if (cm)

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClasses

(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jboolean deep,

jboolean lo, jboolean iq, jboolean ic)

{

CIMType ct = cm->getType ();

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

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

OperationContext ctx;

iJType = _dataType::convertCTypeToJavaType (ct, &fSuccess);

try {

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

cop->getNameSpace(),

cop->getClassName(),

(Boolean)deep,

(Boolean)lo,

(Boolean)iq,

(Boolean)ic);

return DEBUG_ConvertCToJava(

Array<CIMClass>*,

jlong,

new Array<CIMClass> (en));

}

Catch (jEnv);

return iJType;

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getInstance(

(JNIEnv *jEnv, jobject jThs, jint jM)

JNIEnv *jEnv,

jobject jThs,

jlong jCh,

jlong jCop,

jboolean lo,

jboolean iq,

jboolean ic,

jobjectArray jPl)

{

CIMMethod *cm = DEBUG_ConvertJavaToC (jint, CIMMethod*, jM);

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

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

OperationContext ctx;

CIMPropertyList pl;

delete cm;

if (jPl)

pl = getList (jEnv,jPl);

else

pl = CIMPropertyList ();

try {

CIMInstance *inst = new CIMInstance(ch->getInstance(

ctx,

cop->getNameSpace(),

*cop,

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,

pl));

DEBUG_ConvertCleanup (jint, jM);

return DEBUG_ConvertCToJava (CIMInstance*, jlong, inst);

}

Catch (jEnv);

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

return 0;

// ---

}

// - CIMValue

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byte

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance

(JNIEnv *jEnv, jobject jThs, jbyte jb, jboolean notSigned)

(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop)

{

CIMValue *cv = NULL;

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

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

if (notSigned)

OperationContext ctx;

cv = new CIMValue ((Uint8)jb);

else

cv = new CIMValue ((Sint8)jb);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

try {

ch->deleteInstance (ctx,cop->getNameSpace (),*cop);

}

Catch (jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1short

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createInstance

(JNIEnv *jEnv, jobject jThs, jshort js, jboolean notSigned)

(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jlong jCi)

{

CIMValue *cv = NULL;

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

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

if (notSigned)

CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jCi);

cv = new CIMValue ((Uint16)js);

OperationContext ctx;

else

cv = new CIMValue( (Sint16)js);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

try {

}

ci->setPath (*cop);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1makeInt

CIMObjectPath obj = ch->createInstance (ctx,

(JNIEnv *jEnv, jobject jThs, jlong ji, jboolean notSigned)

cop->getNameSpace (),

{

*ci);

CIMValue *cv = NULL;

if (notSigned)

return DEBUG_ConvertCToJava(CIMObjectPath*,jlong,new CIMObjectPath(obj));

cv = new CIMValue ((Uint32)ji);

}

else

Catch (jEnv);

cv = new CIMValue ((Sint32)ji);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1long

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1modifyInstance

(JNIEnv *jEnv, jobject jThs, jlong jl, jboolean notSigned)

(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jlong jCi,

jboolean iq, jobjectArray jPl)

{

CIMValue *cv = NULL;

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

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

if (notSigned)

CIMInstance *ci = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jCi);

cv = new CIMValue ((Uint64)jl);

CIMPropertyList pl = getList (jEnv, jPl);

else

OperationContext ctx;

cv = new CIMValue ((Sint64)jl);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

try {

ci->setPath (*cop);

ch->modifyInstance (ctx,

cop->getNameSpace (),

*ci,

(Boolean)iq,

pl);

}

Catch (jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1float

JNIEXPORT jlong JNICALL

(JNIEnv *jEnv, jobject jThs, jfloat jF)

Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstanceNames(

JNIEnv *jEnv,

jobject jThs,

jlong jCh,

jlong jCop,

jboolean deep)

{

CIMValue *cv = new CIMValue (jF);

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

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

OperationContext ctx;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

try {

Array<CIMObjectPath> enm = ch->enumerateInstanceNames(

ctx,

cop->getNameSpace(),

cop->getClassName());

return DEBUG_ConvertCToJava(

Array<CIMObjectPath>*,

jlong,

new Array<CIMObjectPath> (enm));

}

Catch (jEnv);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1double

return 0;

(JNIEnv *jEnv, jobject jThs, jdouble jD)

{

CIMValue *cv = new CIMValue (jD);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1string

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstances

(JNIEnv *jEnv, jobject jThs, jstring jS)

(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jboolean deep,

jboolean lo, jboolean iq, jboolean ic, jobjectArray jPl)

{

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

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

CIMValue *cv = new CIMValue (String (str));

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

CIMPropertyList pl;

OperationContext ctx;

jEnv->ReleaseStringUTFChars (jS,str);

if (jPl)

pl = getList (jEnv, jPl);

else

pl = CIMPropertyList ();

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

try {

}

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

cop->getNameSpace (),

cop->getClassName (),

(Boolean)deep,

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,

pl);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1cop

return DEBUG_ConvertCToJava(

(JNIEnv *jEnv, jobject jThs, jint jR)

Array<CIMInstance>*,

{

jlong,

CIMObjectPath *ref = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jR);

new Array<CIMInstance> (en));

CIMValue *cv = new CIMValue (*ref);

}

Catch (jEnv);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1datetime

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1execQuery(

(JNIEnv *jEnv, jobject jThs, jint jDT)

JNIEnv *jEnv,

jobject jThs,

jlong jCh,

jlong jCop,

jstring jQuery,

jstring jQl)

{

CIMDateTime *dt = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jDT);

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

CIMValue *cv = new CIMValue (*dt);

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

OperationContext ctx;

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

String query (str);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

jEnv->ReleaseStringUTFChars (jQuery,str);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1char16

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

(JNIEnv *jEnv, jobject jThs, jchar jChar16)

{

Char16 c16 (jChar16);

CIMValue *cv = new CIMValue (c16);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

String ql (str);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1object

jEnv->ReleaseStringUTFChars (jQl, str);

(JNIEnv *jEnv, jobject jThs, jint jO)

{

CIMObject *co = DEBUG_ConvertJavaToC (jint, CIMObject*, jO);

CIMValue *cv = new CIMValue (*co);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

try {

}

Array<CIMObject> enm = ch->execQuery (ctx,

cop->getNameSpace (),

ql,

query);

Array<CIMInstance> *enmInst = new Array<CIMInstance> ();

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMValue__1isArray

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

(JNIEnv *jEnv, jobject jThs, jint jP)

{

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

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

return (jboolean)cv->isArray ();

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1boolean

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

(JNIEnv *jEnv, jobject jThs, jboolean jB)

}

{

Catch (jEnv);

CIMValue *cv = new CIMValue ((Boolean)jB);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byteArray

(JNIEnv *jEnv, jobject jThs, jshortArray jshortA, jboolean notSigned)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength (jshortA);

jshort *jsA = jEnv->GetShortArrayElements (jshortA, &b);

if (notSigned)

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getProperty

(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jstring jN)

{

Array<Uint8> u8;

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

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

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

OperationContext ctx;

u8.append ((Uint8)jsA[i]);

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

CIMName prop (str);

cv = new CIMValue (u8);

jEnv->ReleaseStringUTFChars (jN, str);

}

else

{

Array<Sint8> s8;

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

try {

s8.append ((Sint8)jsA[i]);

CIMValue *cv = new CIMValue (ch->getProperty (ctx,

cop->getNameSpace (),

*cop,

prop));

cv = new CIMValue (s8);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

Catch (jEnv);

jEnv->ReleaseShortArrayElements (jshortA, jsA, len);

return 0;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1shortArray

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setProperty

(JNIEnv *jEnv, jobject jThs, jintArray jintA, jboolean notSigned)

(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop, jstring jPn, jlong jV)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength (jintA);

jint *jiA = jEnv->GetIntArrayElements (jintA, &b);

if (notSigned)

{

Array<Uint16> u16;

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

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

OperationContext ctx;

CIMValue *val = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);

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

CIMName pName (str);

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

jEnv->ReleaseStringUTFChars (jPn, str);

u16.append ((Uint16)jiA[i]);

cv = new CIMValue (u16);

try {

ch->setProperty (ctx,

cop->getNameSpace (),

*cop,

pName,

*val);

}

else

Catch (jEnv);

{

Array<Sint16> s16;

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

s16.append ((Sint16)jiA[i]);

cv = new CIMValue (s16);

}

jEnv->ReleaseIntArrayElements (jintA, jiA, len);

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associatorNames(

JNIEnv *jEnv,

jobject jThs,

jlong jCh,

jlong jCop,

jstring jAssocClass,

jstring jResultClass,

jstring jRole,

jstring jResultRole)

{

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

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

OperationContext ctx;

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

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

CIMName assocClass;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1intArray

if ( str

(JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned)

&& *str

)

{

CIMValue *cv = NULL;

if (CIMName::legal (str))

jboolean b;

jsize len = jEnv->GetArrayLength (jlongA);

jlong *jlA = jEnv->GetLongArrayElements (jlongA, &b);

if (notSigned)

{

Array<Uint32> u32;

assocClass = str;

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

u32.append ((Uint32)jlA[i]);

cv = new CIMValue (u32);

}

else

{

Array<Sint32> s32;

jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF(

"Invalid association class name"));

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

jEnv->Throw ((jthrowable)ev);

s32.append ((Sint32)jlA[i]);

cv = new CIMValue (s32);

return 0;

}

jEnv->ReleaseLongArrayElements (jlongA, jlA, len);

jEnv->ReleaseStringUTFChars (jAssocClass, str);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

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

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1longArray

CIMName resultClass;

(JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength (jlongA);

jlong *jlA = jEnv->GetLongArrayElements (jlongA, &b);

if (notSigned)

if ( str

&& *str

)

{

Array<Uint64> u64;

if (CIMName::legal (str))

{

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

resultClass = str;

u64.append ((Uint64)jlA[i]);

cv = new CIMValue (u64);

}

else

{

Array<Sint64> s64;

jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF(

"Invalid result class name"));

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

jEnv->Throw ((jthrowable)ev);

s64.append ((Sint64)jlA[i]);

cv = new CIMValue (s64);

return 0;

}

jEnv->ReleaseLongArrayElements (jlongA, jlA, len);

jEnv->ReleaseStringUTFChars (jResultClass, str);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

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

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1stringArray

String role (str);

(JNIEnv *jEnv, jobject jThs, jobjectArray jstringA)

{

CIMValue *cv = NULL;

jsize len = jEnv->GetArrayLength (jstringA);

Array<String> strA;

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

jEnv->ReleaseStringUTFChars (jRole, str);

{

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

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

strA.append (String (str));

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

jEnv->ReleaseStringUTFChars (jsA, str);

String resultRole (str);

}

cv = new CIMValue (strA);

jEnv->ReleaseStringUTFChars (jResultRole, str);

try {

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

cop->getNameSpace (),

*cop,

assocClass,

resultClass,

role,

resultRole);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

return DEBUG_ConvertCToJava(

Array<CIMObjectPath>*,

jlong,

new Array<CIMObjectPath> (enm));

}

Catch (jEnv);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1booleanArray

return 0;

(JNIEnv *jEnv, jobject jThs, jbooleanArray jboolA)

}

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength (jboolA);

jboolean *jbA = jEnv->GetBooleanArrayElements (jboolA, &b);

Array<Boolean> bA;

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

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associators(

bA.append ((Boolean)jbA[i]);

JNIEnv *jEnv,

jobject jThs,

jlong jCh,

jlong jCop,

jstring jAssocClass,

jstring jResultClass,

jstring jRole,

jstring jResultRole,

jboolean includeQualifiers,

jboolean includeClassOrigin,

jobjectArray jPl)

{

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

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

OperationContext ctx;

CIMPropertyList pl = getList (jEnv, jPl);

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

CIMName assocClass;

cv = new CIMValue (bA);

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->ReleaseBooleanArrayElements (jboolA, jbA, len);

jEnv->Throw ((jthrowable)ev);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1floatArray

jEnv->ReleaseStringUTFChars (jAssocClass, str);

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

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

jEnv->ReleaseFloatArrayElements (jfloatA, jfA, len);

CIMName resultClass;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

resultClass = str;

}

else

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1doubleArray

(JNIEnv *jEnv, jobject jThs, jdoubleArray jdoubleA)

{

CIMValue *cv = NULL;

jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,

jboolean b;

JMPIjvm::jv.CIMExceptionNewISt,

jsize len = jEnv->GetArrayLength (jdoubleA);

(jint)4, // CIM_ERR_INVALID_PARAMETER

jdouble *jdA = jEnv->GetDoubleArrayElements (jdoubleA, &b);

jEnv->NewStringUTF(

Array<double> dA;

"Invalid result class name"));

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

jEnv->Throw ((jthrowable)ev);

dA.append ((double)jdA[i]);

cv = new CIMValue (dA);

return 0;

}

jEnv->ReleaseStringUTFChars (jResultClass, str);

jEnv->ReleaseDoubleArrayElements (jdoubleA, jdA, len);

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

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

String role (str);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1copArray

jEnv->ReleaseStringUTFChars (jRole, str);

(JNIEnv *jEnv, jobject jThs, jintArray jintA)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength (jintA);

jint *jiA = jEnv->GetIntArrayElements (jintA, &b);

Array<CIMObjectPath> cA;

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

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

cA.append (*((CIMObjectPath*)jiA[i]));

cv = new CIMValue (cA);

String resultRole (str);

jEnv->ReleaseIntArrayElements (jintA, jiA, len);

jEnv->ReleaseStringUTFChars (jResultRole, str);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

try {

}

Array<CIMObject> enm = ch->associators(

ctx,

cop->getNameSpace(),

*cop,

assocClass,

resultClass,

role,

resultRole,

(Boolean)includeQualifiers,

(Boolean)includeClassOrigin,

pl);

Array<CIMInstance> *enmInst = new Array<CIMInstance> ();

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1datetimeArray

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

(JNIEnv *jEnv, jobject jThs, jintArray jintA)

{

CIMValue *cv = NULL;

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

jboolean b;

}

jsize len = jEnv->GetArrayLength (jintA);

jint *jiA = jEnv->GetIntArrayElements (jintA, &b);

Array<CIMDateTime> cA;

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

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

cA.append (*((CIMDateTime*)jiA[i]));

}

Catch (jEnv);

cv = new CIMValue (cA);

return 0;

}

jEnv->ReleaseIntArrayElements (jintA, jiA, len);

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1referenceNames

(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop,

jstring jAssocClass, jstring jRole)

{

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

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

OperationContext ctx;

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

CIMName assocClass;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

else

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1objectArray

(JNIEnv *jEnv, jobject jThs, jintArray jintA)

{

CIMValue *cv = NULL;

jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,

jboolean b;

JMPIjvm::jv.CIMExceptionNewISt,

jsize len = jEnv->GetArrayLength (jintA);

(jint)4, // CIM_ERR_INVALID_PARAMETER

jint *jiA = jEnv->GetIntArrayElements (jintA, &b);

jEnv->NewStringUTF(

Array<CIMObject> cA;

"Invalid association class name"));

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

jEnv->Throw ((jthrowable)ev);

cA.append (*((CIMObject*)jiA[i]));

cv = new CIMValue (cA);

return 0;

}

jEnv->ReleaseIntArrayElements (jintA, jiA, len);

jEnv->ReleaseStringUTFChars (jAssocClass, str);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

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

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1char16Array

String role (str);

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

jEnv->ReleaseStringUTFChars (jRole, str);

cA.append (Char16 (jcA[i]));

cv = new CIMValue (cA);

try {

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

cop->getNameSpace (),

*cop,

assocClass,

role);

jEnv->ReleaseCharArrayElements (jcharA, jcA, len);

return DEBUG_ConvertCToJava(

Array<CIMObjectPath>*,

jlong,

new Array<CIMObjectPath> (enm));

}

Catch (jEnv);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1references

(JNIEnv *jEnv, jobject jThs, jint jP)

(JNIEnv *jEnv, jobject jThs, jlong jCh, jlong jCop,

jstring jAssocClass, jstring jRole,

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)

{

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

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

bool fSuccess = false;

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

int iJType = 0;

OperationContext ctx;

CIMPropertyList pl = getList (jEnv, jPl);

iJType = _dataType::convertCTypeToJavaType (cv->getType (), &fSuccess);

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

CIMName assocClass;

return DEBUG_ConvertCToJava (int, jint, iJType);

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

else

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString

(JNIEnv *jEnv, jobject jThs, jint jV)

{

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

jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF(

"Invalid association class name"));

return (jstring)jEnv->NewStringUTF (cv->toString ().getCString ());

jEnv->Throw ((jthrowable)ev);

return 0;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMValue__1getValue

jEnv->ReleaseStringUTFChars (jAssocClass, str);

(JNIEnv *jEnv, jobject jThs, jint jV)

{

JMPIjvm::cacheIDs (jEnv);

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

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

if (cv->isNull ())

String role (str);

return NULL;

CIMType type = cv->getType ();

jEnv->ReleaseStringUTFChars (jRole, str);

if (!cv->isArray ())

try {

{

Array<CIMObject> enm = ch->references (ctx,

switch (type)

cop->getNameSpace (),

{

*cop,

case CIMTYPE_BOOLEAN:

assocClass,

role,

(Boolean)includeQualifiers,

(Boolean)includeClassOrigin,

pl);

Array<CIMInstance> *enmInst = new Array<CIMInstance> ();

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

{

Boolean bo;

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

cv->get (bo);

return jEnv->NewObject (JMPIjvm::jv.BooleanClassRef,

JMPIjvm::jv.BooleanNewZ,

(jboolean)bo);

}

case CIMTYPE_SINT8:

{

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

Sint8 s8;

cv->get (s8);

return jEnv->NewObject (JMPIjvm::jv.ByteClassRef,

JMPIjvm::jv.ByteNewB,

(jbyte)s8);

}

case CIMTYPE_UINT8:

Catch (jEnv);

{

Uint8 u8;

return 0;

cv->get (u8);

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef,

JMPIjvm::jv.UnsignedInt8NewS,

(jshort)u8);

}

case CIMTYPE_SINT16:

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod(

JNIEnv *jEnv,

jobject jThs,

jlong jCh,

jlong jCop,

jstring jMn,

jobject jIn,

jobject jOut)

{

Sint16 s16;

JMPIjvm::cacheIDs (jEnv);

cv->get (s16);

return jEnv->NewObject (JMPIjvm::jv.ShortClassRef,

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

JMPIjvm::jv.ShortNewS,

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

(jshort)s16);

OperationContext ctx;

}

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

case CIMTYPE_UINT16:

CIMName method (str);

jEnv->ReleaseStringUTFChars (jMn,str);

Array<CIMParamValue> in;

Array<CIMParamValue> out;

for (int i=0,m=jEnv->CallIntMethod(jIn,JMPIjvm::jv.VectorSize);i<m;i++)

{

Uint16 u16;

JMPIjvm::checkException (jEnv);

cv->get (u16);

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef,

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

JMPIjvm::jv.UnsignedInt16NewI,

(jint)u16);

JMPIjvm::checkException (jEnv);

jlong jp = jEnv->CallLongMethod(jProp,JMPIjvm::jv.CIMPropertyCInst);

CIMProperty *p = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jp);

JMPIjvm::checkException (jEnv);

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

}

case CIMTYPE_SINT32:

try {

CIMValue *val = new CIMValue (ch->invokeMethod (ctx,

cop->getNameSpace (),

*cop,

method,

in,

out));

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

{

Sint32 s32;

const CIMParamValue &parm = out[i];

cv->get (s32);

const CIMValue v = parm.getValue ();

return jEnv->NewObject (JMPIjvm::jv.IntegerClassRef,

CIMProperty *p = new CIMProperty (parm.getParameterName (),

JMPIjvm::jv.IntegerNewI,

(jint)s32);

v.getArraySize ());

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

jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,

JMPIjvm::jv.CIMPropertyNewJ,

jp);

jEnv->CallVoidMethod (jOut, JMPIjvm::jv.VectorAddElement, prop);

}

case CIMTYPE_UINT32:

return DEBUG_ConvertCToJava (CIMValue*, jlong, val);

{

Uint32 u32;

cv->get (u32);

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef,

JMPIjvm::jv.UnsignedInt32NewJ,

(jlong)u32);

}

case CIMTYPE_SINT64:

Catch (jEnv);

{

Sint64 s64;

return 0;

cv->get (s64);

return jEnv->NewObject (JMPIjvm::jv.LongClassRef,

JMPIjvm::jv.LongNewJ,

(jlong)s64);

}

case CIMTYPE_UINT64:

{

Uint64 u64;

cv->get (u64);

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod24

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

jobjectArray jIn, jobjectArray jOut)

std::ostringstream oss;

{

jstring jString = 0;

JMPIjvm::cacheIDs (jEnv);

jobject jBIG = 0;

oss << u64 << ends;

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

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

OperationContext ctx;

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

CIMName method (str);

jString = jEnv->NewStringUTF (oss.str ().c_str ());

jEnv->ReleaseStringUTFChars (jMn, str);

if (jString)

Array<CIMParamValue> in;

Array<CIMParamValue> out;

if (jIn)

{

jBIG = jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,

for (int i = 0, m = jEnv->GetArrayLength (jIn); i < m; i++)

JMPIjvm::jv.UnsignedInt64NewStr,

{

jString);

JMPIjvm::checkException (jEnv);

}

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,

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

JMPIjvm::jv.UnsignedInt64NewBi,

jBIG);

JMPIjvm::checkException (jEnv);

jlong jp = jEnv->CallLongMethod (jArg,JMPIjvm::jv.CIMArgumentCInst);

CIMParamValue *p = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jp);

JMPIjvm::checkException (jEnv);

in.append (*p);

}

case CIMTYPE_REAL32:

{

float f;

cv->get (f);

return jEnv->NewObject (JMPIjvm::jv.FloatClassRef,

JMPIjvm::jv.FloatNewF,

(jfloat)f);

}

case CIMTYPE_REAL64:

try {

CIMValue *val = new CIMValue (ch->invokeMethod (ctx,

cop->getNameSpace (),

*cop,

method,

in,

out));

if (jOut)

{

double d;

for (int i=0,m=out.size(),o=jEnv->GetArrayLength(jOut);i<m && i<o;i++)

cv->get (d);

return jEnv->NewObject (JMPIjvm::jv.DoubleClassRef,

JMPIjvm::jv.DoubleNewD,

(jdouble)d);

}

case CIMTYPE_STRING:

{

String s;

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

cv->get (s);

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

return jEnv->NewStringUTF (s.getCString ());

jEnv->SetObjectArrayElement(

jOut,

jEnv->NewObject(

JMPIjvm::jv.CIMArgumentClassRef,

JMPIjvm::jv.CIMArgumentNewJ,jParm));

}

case CIMTYPE_REFERENCE:

{

CIMObjectPath ref;

cv->get (ref);

jint jOp = DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath (ref));

return jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef,

JMPIjvm::jv.CIMObjectPathNewI,

jOp);

}

case CIMTYPE_CHAR16:

return DEBUG_ConvertCToJava (CIMValue*, jlong, val);

{

Char16 c16;

cv->get (c16);

return jEnv->NewObject (JMPIjvm::jv.CharacterClassRef,

JMPIjvm::jv.CharacterNewC,

(jchar)c16);

}

case CIMTYPE_DATETIME:

Catch (jEnv);

{

CIMDateTime dt;

return 0;

cv->get (dt);

jint jDT = DEBUG_ConvertCToJava (CIMDateTime*, jint, new CIMDateTime (dt));

return jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef,

JMPIjvm::jv.CIMDateTimeNewI,

jDT);

}

case CIMTYPE_OBJECT:

{

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent(

CIMObject co;

JNIEnv *jEnv,

cv->get (co);

jobject jThs,

if (co.isClass ())

jlong jCh,

jstring jName,

jstring jNs,

jlong jInd)

{

jint jCC = DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass (co));

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

CIMInstance *ind = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInd);

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

String name (str);

jEnv->ReleaseStringUTFChars (jName, str);

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

String ns (str);

jEnv->ReleaseStringUTFChars (jNs, str);

CIMObjectPath ref (ind->getPath ());

ref.setNameSpace (ns);

PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,

"Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent(): ref = %s",

(const char*)ref.toString().getCString()));

PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,

"Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent(): ind = %s",

(const char*)ind->getPath().toString().getCString()));

ind->setPath (ref);

PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,

"Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent(): ind = %s",

(const char*)ind->getPath().toString().getCString()));

JMPIProviderManager::indProvRecord *prec = NULL;

String sPathString = ind->getPath ().toString ();

OperationContext *context = NULL;

bool fResult = false;

return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,

JMPIjvm::jv.CIMObjectNewIZ,

jCC,

(jboolean)true);

}

else

{

jint jCI = DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance (co));

AutoMutex lock (JMPIProviderManager::mutexProvTab);

return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,

fResult = JMPIProviderManager::provTab.lookup (name, prec);

JMPIjvm::jv.CIMObjectNewIZ,

PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,

jCI,

"Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent(): "

(jboolean)false);

"fResult = %d, name = %s",

fResult,(const char*)name.getCString()));

}

if (fResult)

{

if (prec->enabled)

{

try

{

prec->handler->deliver (*prec->ctx, *ind);

}

default:

Catch (jEnv);

throwCIMException (jEnv,"+++ unsupported type: ");

}

else

{

switch (type)

PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL1,

"Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent(): "

"provider name \"%s\" not found",

(const char*)name.getCString()));

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jCh)

{

case CIMTYPE_BOOLEAN:

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

delete ch;

DEBUG_ConvertCleanup (jlong, jCh);

}

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

// ---

// - CIMParameter

// ---

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

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMParameter__1getName

(JNIEnv *jEnv, jobject jThs, jlong jCp)

{

Array<Boolean> bo;

CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);

jstring rv = 0;

cv->get (bo);

if (cp)

{

try

{

CIMName name = cp->getName ();

int s = bo.size ();

rv = jEnv->NewStringUTF (name.getString ().getCString ());

jobjectArray jbooleanA = (jobjectArray)jEnv->NewObjectArray (s,

}

JMPIjvm::jv.BooleanClassRef,

Catch (jEnv);

0);

}

for (int i = 0; i < s; i++)

return rv;

jEnv->SetObjectArrayElement (jbooleanA,

jEnv->NewObject (JMPIjvm::jv.BooleanClassRef,

JMPIjvm::jv.BooleanNewZ,

(jboolean)bo[i]));

return jbooleanA;

}

case CIMTYPE_SINT8:

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMParameter__1setName

(JNIEnv *jEnv, jobject jThs, jlong jCp, jstring jName)

{

CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);

if (cp && jName)

{

Array<Sint8> s8;

try

{

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

cv->get (s8);

CIMName name (cstrName);

int s = s8.size ();

cp->setName (name);

jobjectArray jbyteA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.ByteClassRef,

0);

for (int i = 0; i < s; i++)

jEnv->ReleaseStringUTFChars (jName, cstrName);

jEnv->SetObjectArrayElement (jbyteA,

jEnv->NewObject (JMPIjvm::jv.ByteClassRef,

JMPIjvm::jv.ByteNewB,

(jbyte)s8[i]));

return jbyteA;

}

case CIMTYPE_UINT8:

Catch (jEnv);

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMParameter__1isArray

(JNIEnv *jEnv, jobject jThs, jlong jCp)

{

Array<Uint8> u8;

CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);

jboolean rv = 0;

cv->get (u8);

if (cp)

{

try

{

rv = cp->isArray ();

}

Catch (jEnv);

}

int s = u8.size ();

return rv;

jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.UnsignedInt8ClassRef,

0);

for (int i = 0; i < s; i++)

jEnv->SetObjectArrayElement (jshortA,

jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef,

JMPIjvm::jv.UnsignedInt8NewS,

(jshort)u8[i]));

return jshortA;

}

case CIMTYPE_SINT16:

{

Array<Sint16> s16;

cv->get (s16);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMParameter__1getArraySize

(JNIEnv *jEnv, jobject jThs, jlong jCp)

{

CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);

jint rv = 0;

int s = s16.size ();

if (cp)

jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray (s,

{

JMPIjvm::jv.ShortClassRef,

try

0);

{

rv = cp->getArraySize ();

}

Catch (jEnv);

}

for (int i = 0; i < s; i++)

return rv;

jEnv->SetObjectArrayElement (jshortA,

jEnv->NewObject (JMPIjvm::jv.ShortClassRef,

JMPIjvm::jv.ShortNewS,

(jshort)s16[i]));

return jshortA;

}

case CIMTYPE_UINT16:

JNIEXPORT jstring JNICALL

Java_org_pegasus_jmpi_CIMParameter__1getReferenceClassName(

JNIEnv *jEnv,

jobject jThs,

jlong jCp)

{

Array<Uint16> u16;

CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);

jstring rv = 0;

cv->get (u16);

if (cp)

{

try

{

CIMName name = cp->getReferenceClassName ();

int s = u16.size ();

rv = jEnv->NewStringUTF (name.getString ().getCString ());

jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray (s,

}

JMPIjvm::jv.UnsignedInt16ClassRef,

Catch (jEnv);

0);

}

for (int i = 0; i < s; i++)

return rv;

jEnv->SetObjectArrayElement (jintA,

jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef,

JMPIjvm::jv.UnsignedInt16NewI,

(jint)u16[i]));

return jintA;

}

case CIMTYPE_SINT32:

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMParameter__1getType

(JNIEnv *jEnv, jobject jThs, jlong jCp)

{

Array<Sint32> s32;

CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);

jlong rv = 0;

cv->get (s32);

if (cp)

{

try

{

CIMType ct = cp->getType ();

bool fSuccess = false;

String ref = cp->getReferenceClassName ().getString ();

int iJType = 0;

_dataType *type = 0;

int s = s32.size ();

iJType = _dataType::convertCTypeToJavaType (ct, &fSuccess);

jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.IntegerClassRef,

0);

for (int i = 0; i < s; i++)

if (fSuccess)

jEnv->SetObjectArrayElement (jintA,

jEnv->NewObject (JMPIjvm::jv.IntegerClassRef,

JMPIjvm::jv.IntegerNewI,

(jint)s32[i]));

return jintA;

}

case CIMTYPE_UINT32:

{

Array<Uint32> u32;

type = new _dataType (iJType,

cp->getArraySize (),

cv->get (u32);

false,

cp->isArray (),

ref,

true);

int s = u32.size ();

rv = DEBUG_ConvertCToJava (_dataType*, jlong, type);

jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray (s,

}

JMPIjvm::jv.UnsignedInt32ClassRef,

}

0);

Catch (jEnv);

}

for (int i = 0; i < s; i++)

return rv;

jEnv->SetObjectArrayElement (jlongA,

jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef,

JMPIjvm::jv.UnsignedInt32NewJ,

(jlong)u32[i]));

return jlongA;

}

case CIMTYPE_SINT64:

{

Array<Sint64> s64;

cv->get (s64);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMParameter__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jCp)

{

CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);

int s = s64.size ();

delete cp;

jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.LongClassRef,

0);

for (int i = 0; i < s; i++)

DEBUG_ConvertCleanup (jlong, jCp);

jEnv->SetObjectArrayElement (jlongA,

jEnv->NewObject (JMPIjvm::jv.LongClassRef,

JMPIjvm::jv.LongNewJ,

(jlong)s64[i]));

return jlongA;

}

case CIMTYPE_UINT64:

{

Array<Uint64> u64;

cv->get (u64);

int s = u64.size ();

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

jobjectArray ju64A = (jobjectArray)jEnv->NewObjectArray (s,

// ---

JMPIjvm::jv.UnsignedInt64ClassRef,

// - CIMProperty

0);

// ---

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

for (int i = 0; i < s; i++)

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1getValue

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

std::ostringstream oss;

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

jstring jString = 0;

CIMValue *cv = new CIMValue (cp->getValue ());

jobject jBIG = 0;

oss << u64[i] << ends;

jString = jEnv->NewStringUTF (oss.str ().c_str ());

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

if (jString)

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getName

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

jBIG = jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

JMPIjvm::jv.UnsignedInt64NewStr,

const String &n = cp->getName ().getString ();

jString);

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

return str;

}

if (jBIG)

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setName

(JNIEnv *jEnv, jobject jThs, jlong jP, jstring jN)

{

jEnv->SetObjectArrayElement (ju64A,

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

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

jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,

JMPIjvm::jv.UnsignedInt64NewBi,

cp->setName (CIMName (str));

jBIG));

jEnv->ReleaseStringUTFChars (jN,str);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1property

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

{

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

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

CIMProperty *cp = 0;

jlong jCp = 0;

try {

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

{

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

}

return ju64A;

else

{

if (!cv->isArray ())

{

CIMObjectPath cop;

cv->get (cop);

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

}

case CIMTYPE_REAL32:

else

{

Array<Real32> r32;

throwCIMException(

jEnv,

"+++ unsupported type in CIMProperty.property");

}

cv->get (r32);

jCp = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp);

}

Catch (jEnv);

int s = r32.size ();

jEnv->ReleaseStringUTFChars (jN, str);

jobjectArray jfloatA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.FloatClassRef,

0);

for (int i = 0; i < s; i++)

return jCp;

jEnv->SetObjectArrayElement (jfloatA,

jEnv->NewObject (JMPIjvm::jv.FloatClassRef,

JMPIjvm::jv.FloatNewF,

(jfloat)r32[i]));

return jfloatA;

}

case CIMTYPE_REAL64:

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1new

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

{

Array<Real64> r64;

CIMProperty *p = new CIMProperty (CIMName (),CIMValue ());

cv->get (r64);

return DEBUG_ConvertCToJava (CIMProperty*, jlong, p);

}

int s = r64.size ();

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isReference

jobjectArray jdoubleA = (jobjectArray)jEnv->NewObjectArray (s,

(JNIEnv *jEnv, jobject jThs, jlong jP)

JMPIjvm::jv.DoubleClassRef,

{

0);

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

for (int i = 0; i < s; i++)

return (jboolean) (cp->getType () == CIMTYPE_REFERENCE);

jEnv->SetObjectArrayElement (jdoubleA,

jEnv->NewObject (JMPIjvm::jv.DoubleClassRef,

JMPIjvm::jv.DoubleNewD,

(jdouble)r64[i]));

return jdoubleA;

}

case CIMTYPE_STRING:

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getRefClassName

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

Array<String> str;

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

const String &n = cp->getReferenceClassName ().getString ();

cv->get (str);

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

int s = str.size ();

return str;

jobjectArray jstringA = (jobjectArray)jEnv->NewObjectArray (s,

}

JMPIjvm::jv.StringClassRef,

0);

for (int i = 0; i < s; i++)

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1getType

jEnv->SetObjectArrayElement (jstringA,

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

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

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

return jstringA;

String ref = cp->getReferenceClassName ().getString ();

bool fSuccess = false;

int iJType = 0;

_dataType *type = 0;

iJType = _dataType::convertCTypeToJavaType (cp->getType (), &fSuccess);

if (fSuccess)

{

type = new _dataType (iJType,

cp->getArraySize (),

ref.size () ? true : false,

false,

cp->isArray (),

ref,

true);

}

case CIMTYPE_REFERENCE:

{

Array<CIMObjectPath> ref;

cv->get (ref);

return DEBUG_ConvertCToJava (_dataType*, jlong, type);

}

int s = ref.size ();

jobjectArray jrefA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.CIMObjectPathClassRef,

0);

for (int i = 0; i < s; i++)

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1setType

(JNIEnv *jEnv, jobject jThs, jlong jP, jlong jDt)

{

jint jOP = DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath (ref[i]));

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);

CIMValue val;

bool fSuccess = false;

CIMType cType = CIMTYPE_BOOLEAN;

jEnv->SetObjectArrayElement (jrefA,

cType = _dataType::convertJavaTypeToCType (dt->_type, &fSuccess);

jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef,

if (fSuccess)

JMPIjvm::jv.CIMObjectPathNewI,

jOP));

}

return jrefA;

}

case CIMTYPE_CHAR16:

{

Array<Char16> c16;

val.setNullValue (cType, dt->_array);

cv->get (c16);

CIMProperty *np = new CIMProperty (cp->getName (), val);

int s = c16.size ();

delete cp;

jobjectArray jc16A = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.CharacterClassRef,

0);

for (int i = 0; i < s; i++)

DEBUG_ConvertCleanup (jlong, jP);

jEnv->SetObjectArrayElement (jc16A,

jEnv->NewObject (JMPIjvm::jv.CharacterClassRef,

JMPIjvm::jv.CharacterNewC,

(jchar)c16[i]));

return jc16A;

return DEBUG_ConvertCToJava (CIMProperty*, jlong, np);

}

case CIMTYPE_DATETIME:

else

{

Array<CIMDateTime> dt;

return DEBUG_ConvertCToJava (CIMProperty*, jlong, cp);

}

cv->get (dt);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setValue

(JNIEnv *jEnv, jobject jThs, jlong jP,jlong jV)

{

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

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

int s = dt.size ();

cp->setValue (*cv);

jobjectArray jdtA = (jobjectArray)jEnv->NewObjectArray (s,

}

JMPIjvm::jv.CIMDateTimeClassRef,

0);

for (int i = 0; i < s; i++)

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isArray

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

jint jDT = DEBUG_ConvertCToJava (CIMDateTime*, jint, new CIMDateTime (dt[i]));

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

jEnv->SetObjectArrayElement (jdtA,

return (jboolean)cp->isArray ();

jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef,

JMPIjvm::jv.CIMDateTimeNewI,

jDT));

}

return jdtA;

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getIdentifier

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

const String &n = cp->getName ().getString ();

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

return str;

}

case CIMTYPE_OBJECT:

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addValue

(JNIEnv *jEnv, jobject jThs, jlong jP, jlong jV)

{

Array<CIMObject> co;

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

CIMValue *cvin = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);

CIMValue cv = cp->getValue ();

cv->get (co);

if (cvin->isNull ())

throwCIMException (jEnv,"+++ null cvin value ");

if (!cv.isArray ())

throwCIMException (jEnv,"+++ not an array ");

if (cvin->getType ()!= cv.getType ())

throwCIMException (jEnv,"+++ type mismatch ");

int s = co.size ();

CIMType type = cv.getType ();

jobjectArray jcoA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.CIMObjectClassRef,

0);

for (int i = 0; i < s; i++)

switch (type)

{

if (co[i].isClass ())

case CIMTYPE_BOOLEAN:

{

jint jCC = DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass (co[i]));

Boolean bo;

cvin->get (bo);

jEnv->SetObjectArrayElement (jcoA,

Array<Boolean> boarr;

cv.get (boarr);

jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,

boarr.append (bo);

JMPIjvm::jv.CIMObjectNewIZ,

cv.set (boarr);

jCC,

break;

(jboolean)true));

}

else

case CIMTYPE_UINT8:

{

jint jCI = DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance (co[i]));

Uint8 u8;

cvin->get (u8);

jEnv->SetObjectArrayElement (jcoA,

Array<Uint8> u8arr;

cv.get (u8arr);

jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,

u8arr.append (u8);

JMPIjvm::jv.CIMObjectNewIZ,

cv.set (u8arr);

jCI,

break;

(jboolean)false));

}

case CIMTYPE_SINT8:

{

Sint8 s8;

cvin->get (s8);

Array<Sint8> s8arr;

cv.get (s8arr);

s8arr.append (s8);

cv.set (s8arr);

break;

}

return jcoA;

case CIMTYPE_UINT16:

{

Uint16 u16;

cvin->get (u16);

Array<Uint16> u16arr;

cv.get (u16arr);

u16arr.append (u16);

cv.set (u16arr);

break;

}

default:

case CIMTYPE_SINT16:

throwCIMException (jEnv,"+++ unsupported type: ");

{

Sint16 s16;

cvin->get (s16);

Array<Sint16> s16arr;

cv.get (s16arr);

s16arr.append (s16);

cv.set (s16arr);

break;

}

case CIMTYPE_UINT32:

{

Uint32 u32;

cvin->get (u32);

Array<Uint32> u32arr;

cv.get (u32arr);

u32arr.append (u32);

cv.set (u32arr);

break;

}

case CIMTYPE_SINT32:

return NULL;

{

Sint32 s32;

cvin->get (s32);

Array<Sint32> s32arr;

cv.get (s32arr);

s32arr.append (s32);

cv.set (s32arr);

break;

}

case CIMTYPE_UINT64:

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMValue__1finalize

(JNIEnv *jEnv, jobject jThs, jint jV)

{

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

Uint64 u64;

cvin->get (u64);

delete cv;

Array<Uint64> u64arr;

cv.get (u64arr);

DEBUG_ConvertCleanup (jint, jV);

u64arr.append (u64);

cv.set (u64arr);

break;

}

case CIMTYPE_SINT64:

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

// ---

// - CIMNameSpace

// ---

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

_nameSpace::_nameSpace ()

{

port_ = 0;

Sint64 s64;

hostName_ = System::getHostName ();

cvin->get (s64);

nameSpace_ = "root/cimv2";

Array<Sint64> s64arr;

cv.get (s64arr);

s64arr.append (s64);

cv.set (s64arr);

break;

}

case CIMTYPE_REAL32:

_nameSpace::_nameSpace (String hn)

{

port_ = 0;

Real32 f;

hostName_ = hn;

cvin->get (f);

nameSpace_ = "root/cimv2";

Array<Real32> farr;

cv.get (farr);

farr.append (f);

cv.set (farr);

break;

}

case CIMTYPE_REAL64:

_nameSpace::_nameSpace (String hn, String ns)

{

port_ = 0;

Real64 d;

hostName_ = hn;

cvin->get (d);

nameSpace_ = ns;

Array<Real64> darr;

cv.get (darr);

darr.append (d);

cv.set (darr);

break;

}

case CIMTYPE_CHAR16:

int _nameSpace::port ()

{

if (port_)

Char16 c16;

return port_;

cvin->get (c16);

Array<Char16> c16arr;

port_ = 5988;

cv.get (c16arr);

c16arr.append (c16);

if (hostName_.subString (0,7) == "http://")

cv.set (c16arr);

break;

}

case CIMTYPE_STRING:

{

protocol_ = "http://";

String str;

hostName_ = hostName_.subString (7);

cvin->get (str);

Array<String> strarr;

cv.get (strarr);

strarr.append (str);

cv.set (strarr);

break;

}

case CIMTYPE_DATETIME:

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

if (p >= 0)

{

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

CIMDateTime dt;

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

cvin->get (dt);

Array<CIMDateTime> dtarr;

hostName_.remove (p);

cv.get (dtarr);

dtarr.append (dt);

cv.set (dtarr);

break;

}

case CIMTYPE_REFERENCE:

return port_;

{

CIMObjectPath ref;

cvin->get (ref);

Array<CIMObjectPath> refarr;

cv.get (refarr);

refarr.append (ref);

cv.set (refarr);

break;

}

case CIMTYPE_OBJECT:

String _nameSpace::hostName ()

{

port ();

CIMObject obj;

return hostName_;

cvin->get (obj);

Array<CIMObject> objarr;

cv.get (objarr);

objarr.append (obj);

cv.set (objarr);

break;

}

default:

String _nameSpace::nameSpace ()

{

return nameSpace_;

throwCIMException (jEnv,"+++ unsupported type ");

}

cp->setValue (cv);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1new

(JNIEnv *jEnv, jobject jThs)

{

return DEBUG_ConvertCToJava (_nameSpace*, jint, new _nameSpace ());

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHn

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addQualifier

(JNIEnv *jEnv, jobject jThs, jstring jHn)

(JNIEnv *jEnv, jobject jThs, jlong jP, jlong jQ)

{

const char *hn = jEnv->GetStringUTFChars (jHn, NULL);

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

jint cInst = DEBUG_ConvertCToJava (_nameSpace*, jint, new _nameSpace (hn));

CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ);

jEnv->ReleaseStringUTFChars (jHn, hn);

cp->addQualifier (*cq);

return cInst;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHnNs

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1finalize

(JNIEnv *jEnv, jobject jThs, jstring jHn, jstring jNs)

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

const char *hn = jEnv->GetStringUTFChars (jHn, NULL);

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

const char *ns = jEnv->GetStringUTFChars (jNs, NULL);

jint cInst = DEBUG_ConvertCToJava (_nameSpace*, jint, new _nameSpace (String (hn),String (ns)));

jEnv->ReleaseStringUTFChars (jHn, hn);

delete cp;

jEnv->ReleaseStringUTFChars (jNs, ns);

return cInst;

DEBUG_ConvertCleanup (jlong, jP);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getHost

(JNIEnv *jEnv, jobject jThs, jint jNs)

* 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, jlong jP, jstring jQualifier)

{

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

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

const String &hn = cNs->hostName_;

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

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

Uint32 index = PEG_NOT_FOUND;

return str;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getNameSpace

try

(JNIEnv *jEnv, jobject jThs, jint jNs)

{

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

index = cp->findQualifier (CIMName (str));

const String &ns = cNs->nameSpace_;

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

return str;

jEnv->ReleaseStringUTFChars (jQualifier, str);

}

Catch (jEnv);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setHost

return index;

(JNIEnv *jEnv, jobject jThs, jint jNs, jstring jHn)

{

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

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

cNs->port_ = 0;

cNs->hostName_ = str;

jEnv->ReleaseStringUTFChars (jHn, str);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setNameSpace

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

* Class: org_pegasus_jmpi_CIMProperty

* Method: _getQualifier

* Signature: (I)I

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1getQualifier

(JNIEnv *jEnv, jobject jThs, jlong jP, jint jIndex)

{

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

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

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

CIMQualifier *cq = NULL;

CIMQualifier qualifier;

cNs->nameSpace_ = str;

jEnv->ReleaseStringUTFChars (jN, str);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1finalize

try

(JNIEnv *jEnv, jobject jThs, jint jNs)

{

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

qualifier = cp->getQualifier ((Uint32)jIndex);

cq = new CIMQualifier (qualifier);

delete cNs;

}

Catch (jEnv);

DEBUG_ConvertCleanup (jint, jNs);

return DEBUG_ConvertCToJava (CIMQualifier *, jlong, cq);

}

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

// ---

// - Enumerators

// - CIMQualifier

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1getClass

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMQualifier__1new

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

Array<CIMClass> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMClass>*, jEnum);

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

CIMQualifier *qual = new CIMQualifier (CIMName (str),CIMValue ());

return DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass ((*enm)[pos]));

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1size

jEnv->ReleaseStringUTFChars (jN,str);

(JNIEnv *jEnv, jobject jThs, jint jEnum)

{

Array<CIMClass> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMClass>*, jEnum);

return enm->size ();

return DEBUG_ConvertCToJava (CIMQualifier*, jlong, qual);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getName

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1getInstance

(JNIEnv *jEnv, jobject jThs, jlong jQ)

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)

{

Array<CIMInstance> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMInstance>*, jEnum);

CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ);

const String &n = cq->getName ().getString ();

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

return DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance ((*enm)[pos]));

return str;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1size

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getValue

(JNIEnv *jEnv, jobject jThs, jint jEnum)

(JNIEnv *jEnv, jobject jThs, jlong jQ)

{

Array<CIMInstance> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMInstance>*, jEnum);

CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ);

CIMValue *cv = new CIMValue (cq->getValue ());

return enm->size ();

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1getObjectPath

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1setValue

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)

(JNIEnv *jEnv, jobject jThs, jlong jQ,jlong jV)

{

Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMObjectPath>*, jEnum);

CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ);

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

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath ((*enm)[pos]));

cq->setValue (*cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1size

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1finalize

(JNIEnv *jEnv, jobject jThs, jint jEnum)

(JNIEnv *jEnv, jobject jThs, jlong jQ)

{

Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMObjectPath>*, jEnum);

CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ);

return enm->size ();

delete cq;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1getQualifierType

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)

{

Array<CIMQualifierDecl> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMQualifierDecl>*, jEnum);

return DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, new CIMQualifierDecl ((*enm)[pos]));

DEBUG_ConvertCleanup (jlong, jQ);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1size

(JNIEnv *jEnv, jobject jThs, jint jEnum)

{

Array<CIMQualifierDecl> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMQualifierDecl>*, jEnum);

return enm->size ();

}

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

// ---

// - CIMClient

// - CIMQualifierType

// ---

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

void checkNs (CIMObjectPath *cop, jint jNs)

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1new

{

(JNIEnv *jEnv, jobject jThs)

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

{

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

CIMQualifierDecl *qual = new CIMQualifierDecl ();

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

return DEBUG_ConvertCToJava (CIMQualifierDecl*, jlong, qual);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1newNaUnPw

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1getName

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

(JNIEnv *jEnv, jobject jThs, jlong jQ)

{

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

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

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

const String &n = qt->getName ().getString ();

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

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

jint jCc = 0;

try {

CIMClient *cc = new CIMClient ();

cc->connect (cNs->hostName (), cNs->port (), un, pw);

jCc = DEBUG_ConvertCToJava (CIMClient*, jint, cc);

return str;

}

Catch (jEnv);

jEnv->ReleaseStringUTFChars (jUn, un);

jEnv->ReleaseStringUTFChars (jPw, pw);

return jCc;

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setName

}

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

{

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

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

jlong jret = 0;

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1disconnect

if (qt->isUninitialized ())

(JNIEnv *jEnv, jobject jThs, jint jCc)

{

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

CIMQualifierDecl *nqt = new CIMQualifierDecl(

CIMName(str),

CIMValue(),

CIMScope());

try {

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

cCc->disconnect ();

}

Catch (jEnv);

}

else

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getClass

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean lo,

jboolean iq, jboolean ic, jobjectArray jPl)

{

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

qt->setName (CIMName (str));

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

CIMPropertyList pl = getList (jEnv, jPl);

if ( cCc

CIMQualifierDecl *nqt = new CIMQualifierDecl (*qt);

&& cop

)

{

try {

checkNs (cop, jNs);

CIMClass cls = cCc->getClass (cop->getNameSpace (),

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

cop->getClassName (),

}

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,

pl);

CIMObjectPath copNew = cls.getPath ();

copNew.setNameSpace (cop->getNameSpace ());

jEnv->ReleaseStringUTFChars (jN, str);

cls.setPath (copNew);

return DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass (cls));

return jret;

}

Catch (jEnv);

}

return 0;

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setValue

(JNIEnv *jEnv, jobject jThs, jlong jQ,jlong jV)

{

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

CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);

qt->setValue (*cv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteClass

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1finalize

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop)

(JNIEnv *jEnv, jobject jThs, jlong jQ)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jlong, CIMQualifierDecl*, jQ);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

try {

delete qt;

checkNs (cop, jNs);

cCc->deleteClass (cop->getNameSpace (),

DEBUG_ConvertCleanup (jlong, jQ);

cop->getClassName ());

}

Catch (jEnv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createClass

// -------------------------------------

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, int jCl)

// ---

// - CIMValue

// ---

// -------------------------------------

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1byte

(JNIEnv *jEnv, jobject jThs, jbyte jb, jboolean notSigned)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMValue *cv = NULL;

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMClass *cl = DEBUG_ConvertJavaToC (jint, CIMClass*, jCl);

try {

if (notSigned)

cCc->createClass (cop->getNameSpace (), *cl);

cv = new CIMValue ((Uint8)jb);

}

else

Catch (jEnv);

cv = new CIMValue ((Sint8)jb);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setClass

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1short

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jCl)

(JNIEnv *jEnv, jobject jThs, jshort js, jboolean notSigned)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMValue *cv = NULL;

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMClass *cl = DEBUG_ConvertJavaToC (jint, CIMClass*, jCl);

try {

if (notSigned)

checkNs (cop, jNs);

cv = new CIMValue ((Uint16)js);

else

cv = new CIMValue( (Sint16)js);

cCc->modifyClass (cop->getNameSpace (), *cl);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

Catch (jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClasses

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1makeInt

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, int jCop, jboolean deep, jboolean lo, jboolean iq, jboolean ic)

(JNIEnv *jEnv, jobject jThs, jlong ji, jboolean notSigned)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMValue *cv = NULL;

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

try {

checkNs (cop, jNs);

Array<CIMClass> enm = cCc->enumerateClasses (cop->getNameSpace (),

if (notSigned)

cop->getClassName (),

cv = new CIMValue ((Uint32)ji);

(Boolean)deep,

else

(Boolean)lo,

cv = new CIMValue ((Sint32)ji);

(Boolean)iq,

(Boolean)ic);

return DEBUG_ConvertCToJava (Array<CIMClass>*, jint, new Array<CIMClass> (enm));

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

Catch (jEnv);

return 0;

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1long

(JNIEnv *jEnv, jobject jThs, jlong jl, jboolean notSigned)

{

CIMValue *cv = NULL;

if (notSigned)

cv = new CIMValue ((Uint64)jl);

else

cv = new CIMValue ((Sint64)jl);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClassNames

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1string

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep)

(JNIEnv *jEnv, jobject jThs, jstring jS)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

const char *str = jEnv->GetStringUTFChars (jS,NULL);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMValue *cv = new CIMValue (String (str));

CIMNamespaceName ns = cop->getNameSpace ();

try {

jEnv->ReleaseStringUTFChars (jS,str);

checkNs (cop, jNs);

Array<CIMName> enm = cCc->enumerateClassNames (ns,

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

cop->getClassName (),

}

(Boolean)deep);

Array<CIMObjectPath> *enmop = new Array<CIMObjectPath> ();

for (int i = 0, m = enm.size (); i < m; i++)

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1boolean

(JNIEnv *jEnv, jobject jThs, jboolean jB)

{

enmop->append (CIMObjectPath (String::EMPTY, ns, enm[i]));

CIMValue *cv = new CIMValue ((Boolean)jB);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, enmop);

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1float

(JNIEnv *jEnv, jobject jThs, jfloat jF)

{

CIMValue *cv = new CIMValue (jF);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

Catch (jEnv);

return 0;

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1double

(JNIEnv *jEnv, jobject jThs, jdouble jD)

{

CIMValue *cv = new CIMValue (jD);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateQualifiers

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1cop

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, int jCop)

(JNIEnv *jEnv, jobject jThs, jlong jR)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *ref = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jR);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMValue *cv = new CIMValue (*ref);

try {

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

checkNs (cop, jNs);

}

Array<CIMQualifierDecl> enm = cCc->enumerateQualifiers (cop->getNameSpace ());

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1datetime

(JNIEnv *jEnv, jobject jThs, jlong jDT)

{

CIMDateTime *dt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jDT);

CIMValue *cv = new CIMValue (*dt);

return DEBUG_ConvertCToJava (Array<CIMQualifierDecl>*, jint, new Array<CIMQualifierDecl> (enm));

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

Catch (jEnv);

return 0;

JNIEXPORT jlong 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*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getInstance

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1object

(JNIEnv *jEnv, jobject jThs, jint jCc, int jNs, int jCop, jboolean lo,

(JNIEnv *jEnv, jobject jThs, jlong jO)

jboolean iq, jboolean ic, jobjectArray jPl)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObject *co = DEBUG_ConvertJavaToC (jlong, CIMObject*, jO);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMValue *cv = new CIMValue (*co);

CIMPropertyList pl = getList (jEnv, jPl);

try {

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

checkNs (cop, jNs);

}

CIMInstance inst = cCc->getInstance (cop->getNameSpace (),

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1byteArray

*cop,

(JNIEnv *jEnv, jobject jThs, jshortArray jshortA, jboolean notSigned)

(Boolean)lo,

{

(Boolean)iq,

CIMValue *cv = NULL;

(Boolean)ic,

jboolean b;

pl);

jsize len = jEnv->GetArrayLength (jshortA);

jshort *jsA = jEnv->GetShortArrayElements (jshortA, &b);

inst.setPath (*cop);

if (notSigned)

{

Array<Uint8> u8;

return DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance (inst));

for (jsize i = 0; i < len; i++)

}

u8.append ((Uint8)jsA[i]);

Catch (jEnv);

return 0;

cv = new CIMValue (u8);

}

else

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteInstance

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

Array<Sint8> s8;

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

try {

for (jsize i = 0; i < len; i++)

checkNs (cop, jNs);

s8.append ((Sint8)jsA[i]);

cCc->deleteInstance (cop->getNameSpace (), *cop);

cv = new CIMValue (s8);

}

Catch (jEnv);

jEnv->ReleaseShortArrayElements (jshortA, jsA, 0);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1createInstance

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1shortArray

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, int jCi)

(JNIEnv *jEnv, jobject jThs, jintArray jintA, jboolean notSigned)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength (jintA);

jint *jiA = jEnv->GetIntArrayElements (jintA, &b);

if (notSigned)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

Array<Uint16> u16;

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);

try {

for (jsize i = 0; i < len; i++)

checkNs (cop, jNs);

u16.append ((Uint16)jiA[i]);

ci->setPath (*cop);

cv = new CIMValue (u16);

}

else

{

Array<Sint16> s16;

CIMObjectPath obj = cCc->createInstance (cop->getNameSpace (), *ci);

for (jsize i = 0; i < len; i++)

s16.append ((Sint16)jiA[i]);

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath (obj));

cv = new CIMValue (s16);

}

Catch (jEnv);

return 0;

jEnv->ReleaseIntArrayElements (jintA, jiA, 0);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1modifyInstance

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1intArray

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jCi,

(JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned)

jboolean iq, jobjectArray jPl)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMValue *cv = NULL;

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

jboolean b;

CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);

jsize len = jEnv->GetArrayLength (jlongA);

CIMPropertyList pl = getList (jEnv, jPl);

jlong *jlA = jEnv->GetLongArrayElements (jlongA, &b);

try {

if (notSigned)

checkNs (cop, jNs);

{

Array<Uint32> u32;

ci->setPath (*cop);

for (jsize i = 0; i < len; i++)

u32.append ((Uint32)jlA[i]);

cCc->modifyInstance (cop->getNameSpace (), *ci, (Boolean)iq, pl);

cv = new CIMValue (u32);

}

Catch (jEnv);

}

else

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstances

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep, jboolean lo,

jboolean iq, jboolean ic, jobjectArray jPl)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

Array<Sint32> s32;

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMPropertyList pl = getList (jEnv,jPl);

try {

checkNs (cop, jNs);

CIMPropertyList props;

for (jsize i = 0; i < len; i++)

Array<CIMInstance> enm = cCc->enumerateInstances (cop->getNameSpace (),

s32.append ((Sint32)jlA[i]);

cop->getClassName (),

(Boolean)deep,

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,pl);

return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, new Array<CIMInstance> (enm));

cv = new CIMValue (s32);

}

Catch (jEnv);

return 0;

jEnv->ReleaseLongArrayElements (jlongA, jlA, 0);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstanceNames

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1longArray

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep)

(JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMValue *cv = NULL;

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

jboolean b;

jsize len = jEnv->GetArrayLength (jlongA);

jlong *jlA = jEnv->GetLongArrayElements (jlongA, &b);

try {

if (notSigned)

checkNs (cop,jNs);

{

Array<Uint64> u64;

Array<CIMObjectPath> enm = cCc->enumerateInstanceNames (cop->getNameSpace (),

for (jsize i = 0; i < len; i++)

cop->getClassName ()); //, (Boolean)deep);

u64.append ((Uint64)jlA[i]);

return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath> (enm));

cv = new CIMValue (u64);

}

Catch (jEnv);

else

{

Array<Sint64> s64;

return 0;

for (jsize i = 0; i < len; i++)

s64.append ((Sint64)jlA[i]);

cv = new CIMValue (s64);

}

jEnv->ReleaseLongArrayElements (jlongA, jlA, 0);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getQualifier

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1stringArray

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop)

(JNIEnv *jEnv, jobject jThs, jobjectArray jstringA)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMValue *cv = NULL;

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

jsize len = jEnv->GetArrayLength (jstringA);

Array<String> strA;

try {

for (jsize i = 0;i < len; i++)

checkNs (cop,jNs);

{

jstring jsA = (jstring)jEnv->GetObjectArrayElement (jstringA, i);

const char *str = jEnv->GetStringUTFChars (jsA, NULL);

CIMQualifierDecl *val = new CIMQualifierDecl (cCc->getQualifier (cop->getNameSpace (),

strA.append (String (str));

cop->getClassName ()));

return DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, val);

jEnv->ReleaseStringUTFChars (jsA, str);

}

Catch (jEnv);

return 0;

cv = new CIMValue (strA);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteQualifier

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1booleanArray

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop)

(JNIEnv *jEnv, jobject jThs, jbooleanArray jboolA)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMValue *cv = NULL;

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

jboolean b;

jsize len = jEnv->GetArrayLength (jboolA);

try {

jboolean *jbA = jEnv->GetBooleanArrayElements (jboolA, &b);

checkNs (cop, jNs);

Array<Boolean> bA;

cCc->deleteQualifier (cop->getNameSpace (), cop->getClassName ());

for (jsize i = 0; i < len; i++)

}

bA.append ((Boolean)jbA[i]);

Catch (jEnv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setQualifier

cv = new CIMValue (bA);

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jQ)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ);

try {

jEnv->ReleaseBooleanArrayElements (jboolA, jbA, 0);

checkNs (cop, jNs);

cCc->setQualifier (cop->getNameSpace (), *qt);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

Catch (jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1floatArray

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn)

(JNIEnv *jEnv, jobject jThs, jfloatArray jfloatA)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMValue *cv = NULL;

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

jboolean b;

const char *str = jEnv->GetStringUTFChars (jPn, NULL);

jsize len = jEnv->GetArrayLength (jfloatA);

CIMName pName (str);

jfloat *jfA = jEnv->GetFloatArrayElements (jfloatA, &b);

jint jCv = 0;

Array<float> fA;

try {

checkNs (cop, jNs);

CIMValue *val = new CIMValue (cCc->getProperty (cop->getNameSpace (), *cop, pName));

for (jsize i = 0; i< len; i++)

fA.append ((float)jfA[i]);

jCv = DEBUG_ConvertCToJava (CIMValue*, jint, val);

cv = new CIMValue (fA);

}

Catch (jEnv);

jEnv->ReleaseStringUTFChars (jPn, str);

jEnv->ReleaseFloatArrayElements (jfloatA, jfA, 0);

return jCv;

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1doubleArray

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn, jint jV)

(JNIEnv *jEnv, jobject jThs, jdoubleArray jdoubleA)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMValue *cv = NULL;

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

jboolean b;

CIMValue *val = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);

jsize len = jEnv->GetArrayLength (jdoubleA);

const char *str = jEnv->GetStringUTFChars (jPn, NULL);

jdouble *jdA = jEnv->GetDoubleArrayElements (jdoubleA, &b);

CIMName pName (str);

Array<double> dA;

try {

for (jsize i = 0; i < len; i++)

checkNs (cop,jNs);

dA.append ((double)jdA[i]);

cCc->setProperty (cop->getNameSpace (), *cop, pName, *val);

cv = new CIMValue (dA);

}

Catch (jEnv);

jEnv->ReleaseStringUTFChars (jPn, str);

jEnv->ReleaseDoubleArrayElements (jdoubleA, jdA, 0);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1copArray

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn, jobject jIn, jobject jOut)

(JNIEnv *jEnv, jobject jThs, jlongArray jlongA)

{

JMPIjvm::cacheIDs (jEnv);

CIMValue *cv = NULL;

jboolean b;

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

jsize len = jEnv->GetArrayLength (jlongA);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

jlong *jiA = jEnv->GetLongArrayElements (jlongA, &b);

const char *str = jEnv->GetStringUTFChars (jMn, NULL);

Array<CIMObjectPath> cA;

CIMName method (str);

jint jCv = 0;

Array<CIMParamValue> in;

Array<CIMParamValue> out;

for (int i = 0,m = jEnv->CallIntMethod (jIn,JMPIjvm::jv.VectorSize); i<m; i++)

for (jsize i = 0; i < len; i++)

{

JMPIjvm::checkException (jEnv);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jiA[i]);

cA.append (*cop);

}

jobject jProp = jEnv->CallObjectMethod (jIn,JMPIjvm::jv.VectorElementAt,i);

cv = new CIMValue (cA);

JMPIjvm::checkException (jEnv);

jEnv->ReleaseLongArrayElements (jlongA, jiA, 0);

jint jp = jEnv->CallIntMethod (jProp,JMPIjvm::jv.CIMPropertyCInst);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp);

}

JMPIjvm::checkException (jEnv);

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1datetimeArray

(JNIEnv *jEnv, jobject jThs, jlongArray jlongA)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength (jlongA);

jlong *jiA = jEnv->GetLongArrayElements (jlongA, &b);

Array<CIMDateTime> cA;

in.append (CIMParamValue (p->getName ().getString (),p->getValue ()));

for (jsize i = 0; i < len; i++)

{

CIMDateTime *cdt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jiA[i]);

cA.append (*cdt);

}

try {

cv = new CIMValue (cA);

checkNs (cop, jNs);

CIMValue *val = new CIMValue (cCc->invokeMethod (cop->getNameSpace (),*cop,method,in,out));

jEnv->ReleaseLongArrayElements (jlongA, jiA, 0);

for (int i = 0,m = out.size (); i<m; i++)

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1objectArray

(JNIEnv *jEnv, jobject jThs, jlongArray jlongA)

{

const CIMParamValue &parm = out[i];

CIMValue *cv = NULL;

const CIMValue v = parm.getValue ();

jboolean b;

CIMProperty *p = new CIMProperty (parm.getParameterName (),v,v.getArraySize ());

jsize len = jEnv->GetArrayLength (jlongA);

jint jp = DEBUG_ConvertCToJava (CIMProperty*, jint, p);

jlong *jiA = jEnv->GetLongArrayElements (jlongA, &b);

jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jp);

Array<CIMObject> cA;

jEnv->CallVoidMethod (jOut,JMPIjvm::jv.VectorAddElement,prop);

for (jsize i = 0; i < len; i++)

{

CIMObject *co = DEBUG_ConvertJavaToC (jlong, CIMObject*, jiA[i]);

cA.append (*co);

}

jCv = DEBUG_ConvertCToJava (CIMValue*, jint, val);

cv = new CIMValue (cA);

}

Catch (jEnv);

jEnv->ReleaseStringUTFChars (jMn,str);

jEnv->ReleaseLongArrayElements (jlongA, jiA, 0);

return jCv;

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod24

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1char16Array

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn,

(JNIEnv *jEnv, jobject jThs, jcharArray jcharA)

jobjectArray jIn, jobjectArray jOut)

{

JMPIjvm::cacheIDs (jEnv);

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength (jcharA);

jchar *jcA = jEnv->GetCharArrayElements (jcharA, &b);

Array<Char16> cA;

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

for (jsize i = 0; i < len; i++)

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

cA.append (Char16 (jcA[i]));

const char *str = jEnv->GetStringUTFChars (jMn, NULL);

CIMName method (str);

jint jCv = 0;

Array<CIMParamValue> in;

Array<CIMParamValue> out;

if (jIn)

cv = new CIMValue (cA);

{

for (int i = 0, m = jEnv->GetArrayLength (jIn); i < m; i++)

{

JMPIjvm::checkException (jEnv);

jobject jArg = jEnv->GetObjectArrayElement (jIn, i);

jEnv->ReleaseCharArrayElements (jcharA, jcA, 0);

JMPIjvm::checkException (jEnv);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

jint jp = jEnv->CallIntMethod (jArg,JMPIjvm::jv.CIMArgumentCInst);

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMValue__1getValue

CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jp);

(JNIEnv *jEnv, jobject jThs, jlong jV)

{

JMPIjvm::cacheIDs (jEnv);

JMPIjvm::checkException (jEnv);

CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);

in.append (*p);

if (cv->isNull ())

}

return NULL;

}

try {

checkNs (cop,jNs);

CIMValue *val = new CIMValue (cCc->invokeMethod (cop->getNameSpace (),

CIMType type = cv->getType ();

*cop,

method,

in,

out));

if (jOut)

if (!cv->isArray ())

{

for (int i = 0,m = out.size (),o = jEnv->GetArrayLength (jOut); i<m && i<o; i++)

switch (type)

{

CIMParamValue *parm = new CIMParamValue (out[i]);

case CIMTYPE_BOOLEAN:

jint jParm = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);

{

Boolean bo;

jEnv->SetObjectArrayElement (jOut,

cv->get (bo);

return jEnv->NewObject (JMPIjvm::jv.BooleanClassRef,

jEnv->NewObject (JMPIjvm::jv.CIMArgumentClassRef,JMPIjvm::jv.CIMArgumentNewI,jParm));

JMPIjvm::jv.BooleanNewZ,

(jboolean)bo);

}

case CIMTYPE_SINT8:

{

Sint8 s8;

cv->get (s8);

return jEnv->NewObject (JMPIjvm::jv.ByteClassRef,

JMPIjvm::jv.ByteNewB,

(jbyte)s8);

}

jCv = DEBUG_ConvertCToJava (CIMValue*, jint, val);

case CIMTYPE_UINT8:

{

Uint8 u8;

cv->get (u8);

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef,

JMPIjvm::jv.UnsignedInt8NewS,

(jshort)u8);

}

Catch (jEnv);

case CIMTYPE_SINT16:

{

jEnv->ReleaseStringUTFChars (jMn, str);

Sint16 s16;

cv->get (s16);

return jCv;

return jEnv->NewObject (JMPIjvm::jv.ShortClassRef,

JMPIjvm::jv.ShortNewS,

(jshort)s16);

}

case CIMTYPE_UINT16:

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jQuery, jstring jQl)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

Uint16 u16;

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

cv->get (u16);

const char *str = jEnv->GetStringUTFChars (jQuery, NULL);

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef,

String query (str);

JMPIjvm::jv.UnsignedInt16NewI,

(jint)u16);

/* @NOTE

}

** This does not work for some reason on the client java code:

case CIMTYPE_SINT32:

** 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:

Sint32 s32;

** printf ("This is a test\n");

cv->get (s32);

return jEnv->NewObject (JMPIjvm::jv.IntegerClassRef,

** To debug these JNI functions insert the following:

JMPIjvm::jv.IntegerNewI,

** if (getenv ("PEGASUS_JMPI_GDB"))

(jint)s32);

** {

}

** bool fLoop = true;

case CIMTYPE_UINT32:

** int i = 0;

{

Uint32 u32;

** while (fLoop)

cv->get (u32);

** {

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef,

** i = 1;

JMPIjvm::jv.UnsignedInt32NewJ,

** }

(jlong)u32);

** }

}

** Export the variable PEGASUS_JMPI_GDB = 1.

case CIMTYPE_SINT64:

** Start gdb in another process.

{

** shell ps -efl

Sint64 s64;

** att <ps number>

cv->get (s64);

** set fLoop = 0

return jEnv->NewObject (JMPIjvm::jv.LongClassRef,

JMPIjvm::jv.LongNewJ,

(jlong)s64);

jEnv->ReleaseStringUTFChars (jQuery, str);

}

case CIMTYPE_UINT64:

str = jEnv->GetStringUTFChars (jQl, NULL);

{

Uint64 u64;

String ql (str);

cv->get (u64);

jEnv->ReleaseStringUTFChars (jQl, str);

std::ostringstream oss;

jstring jString = 0;

jobject jBIG = 0;

try {

oss << u64 << ends;

checkNs (cop, jNs);

Array<CIMObject> enm = cCc->execQuery (cop->getNameSpace (),

jString = jEnv->NewStringUTF (oss.str ().c_str ());

ql,

query);

Array<CIMInstance> *enmInst = new Array<CIMInstance> ();

for (int i = 0,m = enm.size (); i<m; i++)

if (jString)

{

enmInst->append (CIMInstance (enm[i]));

jBIG = jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,

JMPIjvm::jv.UnsignedInt64NewStr,

jString);

}

return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,

JMPIjvm::jv.UnsignedInt64NewBi,

jBIG);

}

Catch (jEnv);

case CIMTYPE_REAL32:

{

return 0;

float f;

cv->get (f);

return jEnv->NewObject (JMPIjvm::jv.FloatClassRef,

JMPIjvm::jv.FloatNewF,

(jfloat)f);

}

case CIMTYPE_REAL64:

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associatorNames

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,

jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

double d;

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

cv->get (d);

const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL);

return jEnv->NewObject (JMPIjvm::jv.DoubleClassRef,

JMPIjvm::jv.DoubleNewD,

CIMName assocClass;

(jdouble)d);

}

if ( str

case CIMTYPE_STRING:

&& *str

)

{

if (CIMName::legal (str))

String s;

cv->get (s);

return jEnv->NewStringUTF (s.getCString ());

}

case CIMTYPE_REFERENCE:

{

CIMObjectPath ref;

cv->get (ref);

jlong jOp = DEBUG_ConvertCToJava(

CIMObjectPath*,

jlong,

new CIMObjectPath (ref));

return jEnv->NewObject(

JMPIjvm::jv.CIMObjectPathClassRef,

JMPIjvm::jv.CIMObjectPathNewJ,

jOp);

}

case CIMTYPE_CHAR16:

{

Char16 c16;

cv->get (c16);

return jEnv->NewObject (JMPIjvm::jv.CharacterClassRef,

JMPIjvm::jv.CharacterNewC,

(jchar)c16);

}

case CIMTYPE_DATETIME:

{

CIMDateTime dt;

cv->get (dt);

jlong jDT = DEBUG_ConvertCToJava(

CIMDateTime*, jlong,

new CIMDateTime(dt));

return jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef,

JMPIjvm::jv.CIMDateTimeNewJ,

jDT);

}

case CIMTYPE_OBJECT:

{

CIMObject co;

cv->get (co);

if (co.isClass ())

{

assocClass = str;

jlong jCC = DEBUG_ConvertCToJava(

CIMClass*,

jlong,

new CIMClass (co));

return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,

JMPIjvm::jv.CIMObjectNewJZ,

jCC,

(jboolean)true);

}

else

{

jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,

jlong jCI = DEBUG_ConvertCToJava(

JMPIjvm::jv.CIMExceptionNewISt,

CIMInstance*,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jlong,

jEnv->NewStringUTF ("Invalid association class name"));

new CIMInstance (co));

jEnv->Throw ((jthrowable)ev);

return 0;

return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,

JMPIjvm::jv.CIMObjectNewJZ,

jCI,

(jboolean)false);

}

default:

jEnv->ReleaseStringUTFChars (jAssocClass,str);

throwCIMException (jEnv,"+++ unsupported type: ");

}

str = jEnv->GetStringUTFChars (jResultClass, NULL);

CIMName resultClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

resultClass = str;

}

else

{

jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,

switch (type)

JMPIjvm::jv.CIMExceptionNewISt,

{

(jint)4, // CIM_ERR_INVALID_PARAMETER

case CIMTYPE_BOOLEAN:

jEnv->NewStringUTF ("Invalid result class name"));

{

Array<Boolean> bo;

jEnv->Throw ((jthrowable)ev);

cv->get (bo);

return 0;

int s = bo.size ();

jobjectArray jbooleanA = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.BooleanClassRef,

0);

for (int i = 0; i < s; i++)

{

jEnv->SetObjectArrayElement(

jbooleanA,

jEnv->NewObject(

JMPIjvm::jv.BooleanClassRef,

JMPIjvm::jv.BooleanNewZ,

(jboolean)bo[i]));

}

return jbooleanA;

}

case CIMTYPE_SINT8:

{

Array<Sint8> s8;

jEnv->ReleaseStringUTFChars (jResultClass, str);

cv->get (s8);

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 {

int s = s8.size ();

checkNs (cop,jNs);

jobjectArray jbyteA = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.ByteClassRef,

0);

Array<CIMObjectPath> enm = cCc->associatorNames (cop->getNameSpace (),

for (int i = 0; i < s; i++)

*cop,

{

assocClass,

jEnv->SetObjectArrayElement(

resultClass,

jbyteA,

role,

resultRole);

jEnv->NewObject(

return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath> (enm));

JMPIjvm::jv.ByteClassRef,

JMPIjvm::jv.ByteNewB,

(jbyte)s8[i]));

}

Catch (jEnv);

return jbyteA;

return 0;

}

case CIMTYPE_UINT8:

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associators

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,

jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole,

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

Array<Uint8> u8;

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMPropertyList pl = getList (jEnv, jPl);

const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL);

CIMName assocClass;

cv->get (u8);

if ( str

int s = u8.size ();

&& *str

jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray(

)

{

JMPIjvm::jv.UnsignedInt8ClassRef,

if (CIMName::legal (str))

0);

for (int i = 0; i < s; i++)

{

assocClass = str;

jEnv->SetObjectArrayElement(

jshortA,

jEnv->NewObject(

JMPIjvm::jv.UnsignedInt8ClassRef,

JMPIjvm::jv.UnsignedInt8NewS,

(jshort)u8[i]));

}

else

return jshortA;

}

case CIMTYPE_SINT16:

{

jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,

Array<Sint16> s16;

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF ("Invalid association class name"));

jEnv->Throw ((jthrowable)ev);

cv->get (s16);

return 0;

int s = s16.size ();

jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.ShortClassRef,

0);

for (int i = 0; i < s; i++)

{

jEnv->SetObjectArrayElement(

jshortA,

jEnv->NewObject(

JMPIjvm::jv.ShortClassRef,

JMPIjvm::jv.ShortNewS,

(jshort)s16[i]));

}

return jshortA;

}

case CIMTYPE_UINT16:

{

Array<Uint16> u16;

jEnv->ReleaseStringUTFChars (jAssocClass, str);

cv->get (u16);

str = jEnv->GetStringUTFChars (jResultClass, NULL);

CIMName resultClass;

int s = u16.size ();

jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.UnsignedInt16ClassRef,

0);

if ( str

for (int i = 0; i < s; i++)

&& *str

)

{

if (CIMName::legal (str))

{

resultClass = str;

jEnv->SetObjectArrayElement(

jintA,

jEnv->NewObject(

JMPIjvm::jv.UnsignedInt16ClassRef,

JMPIjvm::jv.UnsignedInt16NewI,

(jint)u16[i]));

}

else

return jintA;

}

case CIMTYPE_SINT32:

{

jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,

Array<Sint32> s32;

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF ("Invalid result class name"));

jEnv->Throw ((jthrowable)ev);

cv->get (s32);

return 0;

int s = s32.size ();

jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.IntegerClassRef,

0);

for (int i = 0; i < s; i++)

{

jEnv->SetObjectArrayElement(

jintA,

jEnv->NewObject(

JMPIjvm::jv.IntegerClassRef,

JMPIjvm::jv.IntegerNewI,

(jint)s32[i]));

}

return jintA;

}

case CIMTYPE_UINT32:

{

Array<Uint32> u32;

cv->get (u32);

int s = u32.size ();

jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.UnsignedInt32ClassRef,

0);

jEnv->ReleaseStringUTFChars (jResultClass, str);

for (int i = 0; i < s; i++)

{

str = jEnv->GetStringUTFChars (jRole, NULL);

jEnv->SetObjectArrayElement(

jlongA,

jEnv->NewObject(

JMPIjvm::jv.UnsignedInt32ClassRef,

JMPIjvm::jv.UnsignedInt32NewJ,

(jlong)u32[i]));

}

return jlongA;

}

case CIMTYPE_SINT64:

{

Array<Sint64> s64;

String role (str);

cv->get (s64);

jEnv->ReleaseStringUTFChars (jRole, str);

int s = s64.size ();

jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.LongClassRef,

0);

str = jEnv->GetStringUTFChars (jResultRole, NULL);

for (int i = 0; i < s; i++)

{

jEnv->SetObjectArrayElement(

jlongA,

jEnv->NewObject(

JMPIjvm::jv.LongClassRef,

JMPIjvm::jv.LongNewJ,

(jlong)s64[i]));

}

return jlongA;

}

case CIMTYPE_UINT64:

{

Array<Uint64> u64;

cv->get (u64);

int s = u64.size ();

jobjectArray ju64A = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.UnsignedInt64ClassRef,

0);

String resultRole (str);

for (int i = 0; i < s; i++)

{

std::ostringstream oss;

jstring jString = 0;

jobject jBIG = 0;

jEnv->ReleaseStringUTFChars (jResultRole, str);

oss << u64[i] << ends;

try {

jString = jEnv->NewStringUTF (oss.str ().c_str ());

checkNs (cop, jNs);

Array<CIMObject> enm = cCc->associators (cop->getNameSpace (),

if (jString)

*cop,

{

assocClass,

jBIG = jEnv->NewObject(

resultClass,

JMPIjvm::jv.UnsignedInt64ClassRef,

role,

JMPIjvm::jv.UnsignedInt64NewStr,

resultRole,

jString);

(Boolean)includeQualifiers,

}

(Boolean)includeClassOrigin,

pl);

Array<CIMInstance> *enmInst = new Array<CIMInstance> ();

for (int i = 0,m = enm.size (); i<m; i++)

if (jBIG)

{

enmInst->append (CIMInstance (enm[i]));

jEnv->SetObjectArrayElement(

ju64A,

jEnv->NewObject(

JMPIjvm::jv.UnsignedInt64ClassRef,

JMPIjvm::jv.UnsignedInt64NewBi,

jBIG));

}

return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);

}

Catch (jEnv);

return ju64A;

return 0;

}

case CIMTYPE_REAL32:

{

Array<Real32> r32;

cv->get (r32);

int s = r32.size ();

jobjectArray jfloatA = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.FloatClassRef,

0);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1referenceNames

for (int i = 0; i < s; i++)

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,

jstring jAssocClass, jstring jRole)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

jEnv->SetObjectArrayElement(

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

jfloatA,

const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL);

jEnv->NewObject(

JMPIjvm::jv.FloatClassRef,

JMPIjvm::jv.FloatNewF,

(jfloat)r32[i]));

}

return jfloatA;

}

case CIMTYPE_REAL64:

{

Array<Real64> r64;

CIMName assocClass;

cv->get (r64);

if ( str

int s = r64.size ();

&& *str

jobjectArray jdoubleA = (jobjectArray)jEnv->NewObjectArray(

)

JMPIjvm::jv.DoubleClassRef,

0);

for (int i = 0; i < s; i++)

{

if (CIMName::legal (str))

jEnv->SetObjectArrayElement(

jdoubleA,

jEnv->NewObject(

JMPIjvm::jv.DoubleClassRef,

JMPIjvm::jv.DoubleNewD,

(jdouble)r64[i]));

}

return jdoubleA;

}

case CIMTYPE_STRING:

{

assocClass = str;

Array<String> str;

cv->get(str);

int s = str.size ();

jobjectArray jstringA = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.StringClassRef,

0);

for (int i = 0; i < s; i++)

{

jEnv->SetObjectArrayElement(

jstringA,

jEnv->NewStringUTF (str[i].getCString ()));

}

else

return jstringA;

}

case CIMTYPE_REFERENCE:

{

jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,

Array<CIMObjectPath> ref;

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF ("Invalid association class name"));

jEnv->Throw ((jthrowable)ev);

cv->get (ref);

return 0;

int s = ref.size ();

jobjectArray jrefA = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.CIMObjectPathClassRef,

0);

for (int i = 0; i < s; i++)

{

jlong jOP = DEBUG_ConvertCToJava(

CIMObjectPath*,

jlong,

new CIMObjectPath(ref[i]));

jEnv->SetObjectArrayElement (jrefA,

jEnv->NewObject(

JMPIjvm::jv.CIMObjectPathClassRef,

JMPIjvm::jv.CIMObjectPathNewJ,

jOP));

}

return jrefA;

}

case CIMTYPE_CHAR16:

{

Array<Char16> c16;

jEnv->ReleaseStringUTFChars (jAssocClass, str);

cv->get (c16);

str = jEnv->GetStringUTFChars (jRole, NULL);

int s = c16.size ();

jobjectArray jc16A = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.CharacterClassRef,

0);

String role (str);

for (int i = 0; i < s; i++)

{

jEnv->SetObjectArrayElement(

jc16A,

jEnv->NewObject(

JMPIjvm::jv.CharacterClassRef,

JMPIjvm::jv.CharacterNewC,

(jchar)c16[i]));

}

return jc16A;

}

case CIMTYPE_DATETIME:

{

Array<CIMDateTime> dt;

jEnv->ReleaseStringUTFChars (jRole, str);

cv->get (dt);

try {

int s = dt.size ();

checkNs (cop, jNs);

jobjectArray jdtA = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.CIMDateTimeClassRef,

0);

Array<CIMObjectPath> enm = cCc->referenceNames (cop->getNameSpace (),

for (int i = 0; i < s; i++)

*cop,

{

assocClass,

jlong jDT = DEBUG_ConvertCToJava(

role);

CIMDateTime*,

jlong,

new CIMDateTime (dt[i]));

return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath> (enm));

jEnv->SetObjectArrayElement(

jdtA,

jEnv->NewObject(

JMPIjvm::jv.CIMDateTimeClassRef,

JMPIjvm::jv.CIMDateTimeNewJ,

jDT));

}

Catch (jEnv);

return jdtA;

return 0;

}

case CIMTYPE_OBJECT:

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1references

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,

jstring jAssocClass, jstring jRole,

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

Array<CIMObject> co;

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMPropertyList pl = getList (jEnv, jPl);

const char *str = jEnv->GetStringUTFChars (jAssocClass, NULL);

CIMName assocClass;

cv->get (co);

if ( str

int s = co.size ();

&& *str

jobjectArray jcoA = (jobjectArray)jEnv->NewObjectArray(

)

JMPIjvm::jv.CIMObjectClassRef,

0);

for (int i = 0; i < s; i++)

{

if (CIMName::legal (str))

if (co[i].isClass ())

{

assocClass = str;

jlong jCC = DEBUG_ConvertCToJava(

CIMClass*,

jlong,

new CIMClass (co[i]));

jEnv->SetObjectArrayElement(

jcoA,

jEnv->NewObject(

JMPIjvm::jv.CIMObjectClassRef,

JMPIjvm::jv.CIMObjectNewJZ,

jCC,

(jboolean)true));

}

else

{

jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,

jlong jCI = DEBUG_ConvertCToJava(

JMPIjvm::jv.CIMExceptionNewISt,

CIMInstance*,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jlong,

jEnv->NewStringUTF ("Invalid association class name"));

new CIMInstance (co[i]));

jEnv->Throw ((jthrowable)ev);

return 0;

jEnv->SetObjectArrayElement(

jcoA,

jEnv->NewObject(

JMPIjvm::jv.CIMObjectClassRef,

JMPIjvm::jv.CIMObjectNewJZ,

jCI,

(jboolean)false));

}

return jcoA;

jEnv->ReleaseStringUTFChars (jAssocClass, str);

str = jEnv->GetStringUTFChars (jRole, NULL);

String role (str);

jEnv->ReleaseStringUTFChars (jRole, str);

try {

checkNs (cop, jNs);

Array<CIMObject> enm = cCc->references (cop->getNameSpace (),

*cop,

assocClass,

role,

(Boolean)includeQualifiers,

(Boolean)includeClassOrigin,

pl);

Array<CIMInstance> *enmInst = new Array<CIMInstance> ();

for (int i = 0, m = enm.size (); i < m; i++)

{

enmInst->append (CIMInstance (enm[i]));

}

default:

return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);

throwCIMException (jEnv,"+++ unsupported type: ");

}

Catch (jEnv);

return 0;

}

static int normalizeNs (String &ns, String &nsBase, String &lastNsComp)

return NULL;

{

}

Uint32 n = ns.size ();

if (ns[n-1] == '/')

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

if (n>= 2) ns = ns.subString (0,n-2);

CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jP);

}

bool fSuccess = false;

jint jiJType = 0;

lastNsComp = ns;

jiJType = _dataType::convertCTypeToJavaType (cv->getType (), &fSuccess);

nsBase = "root";

n = ns.reverseFind ('/');

return jiJType;

}

if (n!= PEG_NOT_FOUND)

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMValue__1isArray

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

lastNsComp = ns.subString (n+1);

CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jP);

nsBase = ns.subString (0, n);

}

return 0;

return (jboolean)cv->isArray ();

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createNameSpace

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString

(JNIEnv *jEnv, jobject jThs, jint jCc, jstring jNs)

(JNIEnv *jEnv, jobject jThs, jlong jV)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);

const char *str = jEnv->GetStringUTFChars (jNs, NULL);

String ns (str);

jEnv->ReleaseStringUTFChars (jNs, str);

return (jstring)jEnv->NewStringUTF (cv->toString ().getCString ());

}

String lastNsComp;

String nsBase;

normalizeNs (ns, nsBase, lastNsComp);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMValue__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jV)

{

CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);

CIMInstance newInstance (CIMName ("__Namespace"));

delete cv;

newInstance.addProperty (CIMProperty (CIMName ("name"), lastNsComp));

try {

DEBUG_ConvertCleanup (jlong, jV);

cCc->createInstance (CIMNamespaceName (nsBase), newInstance);

}

Catch (jEnv);

}

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 ();

try {

// -------------------------------------

Array<CIMObjectPath> enm = cCc->enumerateInstanceNames (cop->getNameSpace (),

// ---

CIMName ("__Namespace"));

// - ClassEnumeration

// ---

// -------------------------------------

for (int i = 0, s = enm.size (); i < s; i++)

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1getClass

(JNIEnv *jEnv, jobject jThs, jlong jEnum, jint pos)

{

CIMObjectPath& cop = enm[i];

Array<CIMClass> *enm = DEBUG_ConvertJavaToC(jlong, Array<CIMClass>*, jEnum);

const Array<CIMKeyBinding>& kb = cop.getKeyBindings ();

const String& n = kb[0].getValue ();

if (!deep && n.find ('/') != PEG_NOT_FOUND)

return DEBUG_ConvertCToJava (CIMClass*, jlong, new CIMClass ((*enm)[pos]));

continue;

}

String x = ns+"/"+n;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1size

jstring str = jEnv->NewStringUTF (x.getCString ());

(JNIEnv *jEnv, jobject jThs, jlong jEnum)

{

Array<CIMClass> *enm = DEBUG_ConvertJavaToC(jlong, Array<CIMClass>*, jEnum);

jEnv->CallVoidMethod (jVec, JMPIjvm::jv.VectorAddElement, str);

return enm->size ();

}

Catch (jEnv);

return jVec;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteNameSpace

// -------------------------------------

(JNIEnv *jEnv, jobject jThs, jint jCc, jstring jNs)

// ---

// - InstEnumeration

// ---

// -------------------------------------

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_InstEnumeration__1getInstance

(JNIEnv *jEnv, jobject jThs, jlong jEnum, jint pos)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

Array<CIMInstance> *enm = DEBUG_ConvertJavaToC(

const char *str = jEnv->GetStringUTFChars (jNs,NULL);

jlong,

String ns (str);

Array<CIMInstance>*,

jEnum);

jEnv->ReleaseStringUTFChars (jNs,str);

return DEBUG_ConvertCToJava(

CIMInstance*,

jlong,

new CIMInstance((*enm)[pos]));

}

String lastNsComp;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1size

String nsBase;

(JNIEnv *jEnv, jobject jThs, jlong jEnum)

{

Array<CIMInstance> *enm = DEBUG_ConvertJavaToC(

jlong,

Array<CIMInstance>*,

jEnum);

normalizeNs (ns,nsBase,lastNsComp);

return enm->size ();

}

CIMObjectPath cop (String::EMPTY,

// -------------------------------------

CIMNamespaceName (nsBase),

// ---

CIMName ("__Namespace"));

// - JMPIQueryExp

Array<CIMKeyBinding> kb;

// ---

// -------------------------------------

kb.append (CIMKeyBinding (("Name"),CIMValue (lastNsComp)));

cop.setKeyBindings (kb);

* Class: org_pegasus_jmpi_JMPIQueryExp

* Method: _applyInstance

* Signature: (II)Z

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_JMPIQueryExp__1applyInstance

(JNIEnv *jEnv, jobject jThs, jlong jWQLStmt, jlong jciInstance)

{

WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC(

jlong,

WQLSelectStatement*,

jWQLStmt);

CIMInstance *ci = DEBUG_ConvertJavaToC(

jlong,

CIMInstance*,

jciInstance);

try {

if ( !wql_stmt

cCc->deleteInstance (CIMNamespaceName (nsBase), cop);

|| !ci

}

)

Catch (jEnv);

{

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1finalize

try

(JNIEnv *jEnv, jobject jThs, jint jCc)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

return wql_stmt->evaluate (*ci);

}

delete cCc;

catch (const Exception &e)

{

cerr << "Java_org_pegasus_jmpi_JMPIQueryExp__1applyInstance: Caught: "

<< e.getMessage () << endl;

DEBUG_ConvertCleanup (jint, jCc);

return false;

}

// -------------------------------------

// ---

// - CIMObject

// - JMPISelectList

// ---

// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObject__1newClass

(JNIEnv *jEnv, jobject jThs, jint jCc)

* Class: org_pegasus_jmpi_JMPISelectList

* Method: _applyInstance

* Signature: (II)I

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyInstance

(JNIEnv *jEnv, jobject jThs, jlong jWQLStmt, jlong jciInstance)

{

CIMClass *cCc = DEBUG_ConvertJavaToC (jint, CIMClass*, jCc);

WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC(

jlong,

WQLSelectStatement*,

jWQLStmt);

CIMInstance *ci = DEBUG_ConvertJavaToC(

jlong,

CIMInstance*,

jciInstance);

CIMInstance *ciRet = 0;

try {

if ( !wql_stmt

CIMObject *cCo = new CIMObject (*cCc);

|| !ci

)

{

return 0;

}

return DEBUG_ConvertCToJava (CIMObject*, jint, cCo);

ciRet = new CIMInstance (ci->clone ());

if (ciRet)

{

try

{

wql_stmt->applyProjection (*ciRet, false);

}

Catch (jEnv);

catch (const Exception &e)

{

cerr << "Java_org_pegasus_jmpi_JMPISelectList__1applyInstance:"

" Caught: "

<< e.getMessage () << endl;

return 0;

}

return DEBUG_ConvertCToJava (CIMInstance *, jlong, ciRet);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObject__1newInstance

(JNIEnv *jEnv, jobject jThs, jint jCi)

* Class: org_pegasus_jmpi_JMPISelectList

* Method: _applyClass

* Signature: (II)I

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyClass

(JNIEnv *jEnv, jobject jThs, jlong jWQLStmt, jlong jciClass)

{

CIMInstance *cCi = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);

WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC(

jlong,

WQLSelectStatement*,

jWQLStmt);

CIMClass *cc = DEBUG_ConvertJavaToC(

jlong,

CIMClass*,

jciClass);

CIMClass *ccRet = NULL;

try {

if (!wql_stmt)

CIMObject *cCo = new CIMObject (*cCi);

{

return 0;

}

if (cc)

{

CIMObject co (cc->clone ());

return DEBUG_ConvertCToJava (CIMObject*, jint, cCo);

try

{

wql_stmt->applyProjection (co, false);

}

Catch (jEnv);

catch (const Exception &e)

{

cerr << "Java_org_pegasus_jmpi_JMPISelectList__1applyClass: Caught: "

<< e.getMessage () << endl;

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObject__1finalize

ccRet = new CIMClass (co);

(JNIEnv *jEnv, jobject jThs, jint jInst)

{

CIMObject *co = DEBUG_ConvertJavaToC (jint, CIMObject*, jInst);

delete co;

return DEBUG_ConvertCToJava (CIMClass *, jlong, ccRet);

}

DEBUG_ConvertCleanup (jint, jInst);

return 0;

}

// -------------------------------------

// ---

// - OperationContext

Line 6265

Line 7686

* 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)

(JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jContainer, jstring jKey)

{

OperationContext *poc = DEBUG_ConvertJavaToC (jint, OperationContext*, jInst);

OperationContext *poc = DEBUG_ConvertJavaToC(

jlong,

OperationContext*,

jInst);

jobject jRet = 0;

if (!poc)

Line 6280

Line 7704

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);

SubscriptionInstanceContainer sic =

poc->get(SubscriptionInstanceContainer::NAME);

if (key == "subscriptionInstance")

{

CIMInstance ci = sic.getInstance ();

jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance (ci));

jlong jciRef = DEBUG_ConvertCToJava(

CIMInstance*,

jlong,

new CIMInstance (ci));

jRet = jEnv->NewObject (JMPIjvm::jv.CIMInstanceClassRef,

JMPIjvm::jv.CIMInstanceNewI,

JMPIjvm::jv.CIMInstanceNewJ,

jciRef);

}

else if (container == "SubscriptionInstanceNamesContainer")

{

SubscriptionInstanceNamesContainer sinc = poc->get (SubscriptionInstanceNamesContainer::NAME);

SubscriptionInstanceNamesContainer sinc=

poc->get (SubscriptionInstanceNamesContainer::NAME);

if (key == "subscriptionInstanceNames")

{

Line 6323

Line 7743

jobjectArray jcopa = 0;

int jcopaLength = copa.size ();

jcopa = (jobjectArray)jEnv->NewObjectArray (jcopaLength,

jcopa = (jobjectArray)jEnv->NewObjectArray(

jcopaLength,

JMPIjvm::jv.CIMObjectPathClassRef,

0);

for (int i = 0; i < jcopaLength; i++)

{

jEnv->SetObjectArrayElement (jcopa,

jEnv->SetObjectArrayElement(

jcopa,

jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef,

jEnv->NewObject(

JMPIjvm::jv.CIMObjectPathNewI,

JMPIjvm::jv.CIMObjectPathClassRef,

JMPIjvm::jv.CIMObjectPathNewJ,

new CIMObjectPath (copa[i])));

}

Line 6341

Line 7764

}

else if (container == "SubscriptionFilterConditionContainer")

{

SubscriptionFilterConditionContainer sfcc = poc->get (SubscriptionFilterConditionContainer::NAME);

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")

Line 6362

Line 7782

}

else if (container == "SubscriptionFilterQueryContainer")

{

SubscriptionFilterQueryContainer sfqc = poc->get (SubscriptionFilterQueryContainer::NAME);

SubscriptionFilterQueryContainer sfqc =

poc->get(SubscriptionFilterQueryContainer::NAME);

if (key == "filterQuery")

{

Line 6406

Line 7827

return jRet;

}

// -------------------------------------

// ---

// - PathEnumeration

// ---

// -------------------------------------

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_PathEnumeration__1getObjectPath

(JNIEnv *jEnv, jobject jThs, jlong jEnum, jint pos)

{

Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC(

jlong,

Array<CIMObjectPath>*,

jEnum);

return DEBUG_ConvertCToJava(

CIMObjectPath*,

jlong,

new CIMObjectPath((*enm)[pos]));

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1size

(JNIEnv *jEnv, jobject jThs, jlong jEnum)

{

Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC(

jlong,

Array<CIMObjectPath>*,

jEnum);

return enm->size ();

}

// -------------------------------------

// ---

// - QualEnumeration

// ---

// -------------------------------------

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_QualEnumeration__1getQualifierType

(JNIEnv *jEnv, jobject jThs, jlong jEnum, jint pos)

{

Array<CIMQualifierDecl> *enm = DEBUG_ConvertJavaToC(

jlong,

Array<CIMQualifierDecl>*,

jEnum);

return DEBUG_ConvertCToJava(

CIMQualifierDecl*,

jlong,

new CIMQualifierDecl((*enm)[pos]));

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1size

(JNIEnv *jEnv, jobject jThs, jlong jEnum)

{

Array<CIMQualifierDecl> *enm = DEBUG_ConvertJavaToC(

jlong,

Array<CIMQualifierDecl>*,

jEnum);

return enm->size ();

}

// -------------------------------------

// ---

// - SelectExp

Line 6418

Line 7904

* Signature: (I)V

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_SelectExp__1finalize

(JNIEnv *jEnv, jobject jThs, jint jWQLStmt)

(JNIEnv *jEnv, jobject jThs, jlong jWQLStmt)

{

WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jint, WQLSelectStatement*, jWQLStmt);

WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (

jlong,

WQLSelectStatement*,

jWQLStmt);

delete wql_stmt;

DEBUG_ConvertCleanup (jint, jWQLStmt);

DEBUG_ConvertCleanup (jlong, jWQLStmt);

}

Line 6432

Line 7921

* Method: _newSelectExp

* Signature: (Ljava/lang/String;)I

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_SelectExp__1newSelectExp

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_SelectExp__1newSelectExp

(JNIEnv *jEnv, jobject jThs, jstring jQuery)

{

const char *pszQuery = jEnv->GetStringUTFChars (jQuery, NULL);

Line 6441

Line 7930

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));

PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,

"Java_org_pegasus_jmpi_SelectExp__1newSelectExp: wql_stmt = %p",

wql_stmt));

try

{

Line 6449

Line 7941

}

catch (const Exception &e)

{

cerr << "Java_org_pegasus_jmpi_SelectExp__1newSelectExp: Caught: " << e.getMessage () << endl;

PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,

"Java_org_pegasus_jmpi_SelectExp__1newSelectExp: Caught: %s",

(const char*)e.getMessage().getCString()));

}

jEnv->ReleaseStringUTFChars (jQuery, pszQuery);

return DEBUG_ConvertCToJava (WQLSelectStatement *, jint, wql_stmt);

return DEBUG_ConvertCToJava (WQLSelectStatement *, jlong, wql_stmt);

}

Line 6463

Line 7957

* Signature: (I)Ljava/lang/String;

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_SelectExp__1getSelectString

(JNIEnv *jEnv, jobject jThs, jint jWQLStmt)

(JNIEnv *jEnv, jobject jThs, jlong jWQLStmt)

{

WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jint, WQLSelectStatement*, jWQLStmt);

WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC(

jlong,

WQLSelectStatement*,

jWQLStmt);

String cond;

if (wql_stmt)

Line 6476

Line 7973

}

catch (const Exception &e)

{

cerr << "Java_org_pegasus_jmpi_SelectExp__1getSelectString: Caught: " << e.getMessage () << endl;

cerr << "Java_org_pegasus_jmpi_SelectExp__1getSelectString: Caught: "

<< e.getMessage () << endl;

cond = "";

}

Line 6489

Line 7987

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"

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.60
changed lines
	Added in v.1.83

No CVS admin address has been configured