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.14 and 1.80

version 1.14, 2005/03/17 01:56:13

version 1.80, 2008/03/18 15:32:50

Line 1

//%2005////////////////////////////////////////////////////////////////////////

//%2006////////////////////////////////////////////////////////////////////////

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

Line 8

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; Symantec Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 27

Line 29

//==============================================================================

// Author: Adrian Schuur, schuur@de.ibm.com

// Modified By: Adrian Dutta

// Andy Viciu

// Magda Vacarelu

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

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

#endif

#include <iostream>

#include <sstream>

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/System.h>

Line 51

Line 47

#include <Pegasus/Common/CIMInstance.h>

#include <Pegasus/Common/CIMObjectPath.h>

#include <Pegasus/Common/CIMProperty.h>

#include <Pegasus/Common/CIMType.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>

#include <Pegasus/WQL/WQLSelectStatement.h>

#include <Pegasus/WQL/WQLParser.h>

#define CALL_SIGN_WQL "WQL"

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

JavaVM *JMPIjvm::jvm=NULL;

JvmVector JMPIjvm::jv;

int JMPIjvm::trace=0;

typedef struct {

#include "Convert.h"

int clsIndex;

const char * methodName;

JMPIjvm::ClassTable JMPIjvm::_classTable;

const char * signature;

JMPIjvm::ObjectTable JMPIjvm::_objectTable;

} METHOD_STRUCT;

const char* classNames[]={

"java/util/Vector" , // 0

/*00*/ "java/util/Vector" ,

"java/lang/Boolean", // 1

/*01*/ "java/lang/Boolean",

"java/lang/Byte", // 2

/*02*/ "java/lang/Byte",

"java/lang/Short", // 3

/*03*/ "java/lang/Short",

"java/lang/Integer", // 4

/*04*/ "java/lang/Integer",

"java/lang/Long", // 5

/*05*/ "java/lang/Long",

"java/lang/Float", // 6

/*06*/ "java/lang/Float",

"java/lang/Double", // 7

/*07*/ "java/lang/Double",

"org/pegasus/jmpi/UnsignedInt8", // 8

/*08*/ "org/pegasus/jmpi/UnsignedInt8",

"org/pegasus/jmpi/UnsignedInt16", // 9

/*09*/ "org/pegasus/jmpi/UnsignedInt16",

"org/pegasus/jmpi/UnsignedInt32", // 10

/*10*/ "org/pegasus/jmpi/UnsignedInt32",

"org/pegasus/jmpi/UnsignedInt64", // 11

/*11*/ "org/pegasus/jmpi/UnsignedInt64",

"org/pegasus/jmpi/CIMObjectPath", // 12

/*12*/ "org/pegasus/jmpi/CIMObjectPath",

"org/pegasus/jmpi/CIMException", // 13

/*13*/ "org/pegasus/jmpi/CIMException",

"java/math/BigInteger", // 14

/*14*/ "java/math/BigInteger",

"org/pegasus/jmpi/CIMProperty", // 15

/*15*/ "org/pegasus/jmpi/CIMProperty",

/*16*/ "org/pegasus/jmpi/CIMOMHandle",

"org/pegasus/jmpi/CIMOMHandle", // 16

/*17*/ "org/pegasus/jmpi/CIMClass",

"org/pegasus/jmpi/CIMClass", // 17

/*18*/ "org/pegasus/jmpi/CIMInstance",

"org/pegasus/jmpi/CIMInstance", // 18

/*19*/ "org/pegasus/jmpi/CIMValue",

"org/pegasus/jmpi/CIMValue", // 19

/*20*/ "java/lang/Object",

"java/lang/Object", // 20

/*21*/ "java/lang/Throwable",

"java/lang/Throwable", // 21

/*22*/ "java/lang/String",

"java/lang/String", // 22

/*23*/ "org/pegasus/jmpi/JarClassLoader",

"org/pegasus/jmpi/JarClassLoader", // 23

/*24*/ "org/pegasus/jmpi/CIMDateTime",

"org/pegasus/jmpi/CIMDateTime", // 24

/*25*/ "org/pegasus/jmpi/SelectExp",

"org/pegasus/jmpi/SelectExp", // 25

/*26*/ "org/pegasus/jmpi/CIMQualifier",

"org/pegasus/jmpi/CIMQualifier", // 26

/*27*/ "org/pegasus/jmpi/CIMQualifierType",

"org/pegasus/jmpi/CIMQualifierType",// 27

/*28*/ "org/pegasus/jmpi/CIMFlavor",

"org/pegasus/jmpi/CIMFlavor", // 28

/*29*/ "org/pegasus/jmpi/CIMArgument",

"org/pegasus/jmpi/CIMArgument", // 29

/*30*/ "org/pegasus/jmpi/CIMInstanceException",

"org/pegasus/jmpi/CIMInstanceException", // 30

/*31*/ "org/pegasus/jmpi/CIMObject",

/*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*/ { 0, "<init>", "()V" },

/*00 VectorNew */

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

{ /*Vector */

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

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

"<init>",

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

"()V" },

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

/*01 BooleanNewZ */

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

{ /*Boolean */

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

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

"<init>",

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

"(Z)V" },

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

/*02 ByteNewB */

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

{ /*Byte */

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

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

"<init>",

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

"(B)V" },

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

/*03 ShortNewS */

{ /*Short */

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

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

"<init>",

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

"(S)V" },

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

/*04 IntegerNewI */

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

{ /*Integer */

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

/*22*/ { 12,"cInst", "()I" },

"<init>",

/*23*/ { 18,"cInst", "()I" },

"(I)V" },

/*24*/ { 17,"cInst", "()I" },

/*05 LongNewJ */

/*25*/ { 20,"toString", "()Ljava/lang/String;" },

{ /*Long */

/*26*/ { 21,"getMessage", "()Ljava/lang/String;" },

/*27*/ { 13,"getID", "()Ljava/lang/String;" },

"<init>",

/*28*/ { 0, "size", "()I" },

"(J)V" },

/*29*/ { 15,"cInst", "()I" },

/*06 FloatNewF */

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

{ /*Float */

/*31*/ { 0, "removeElementAt", "(I)V" },

/*32*/ { 19,"cInst", "()I" },

"<init>",

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

"(F)V" },

/*34*/ { 13,"getCode", "()I" },

/*07 DoubleNewD */

/*35*/ { 24,"<init>", "(I)V" },

{ /*Double */

/*36*/ { 25,"<init>", "(I)V" },

/*37*/ { 26,"<init>", "(I)V" },

"<init>",

/*38*/ { 28,"<init>", "(I)V" },

"(D)V" },

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

/*08 UnsignedInt8NewS */

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

{ /*UnsignedInt8 */

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

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

"<init>",

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

"(S)V" },

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

/*09 UnsignedInt16NewI */

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

{ /*UnsignedInt16 */

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

"<init>",

"(I)V" },

/*10 UnsignedInt32NewJ */

{ /*UnsignedInt32 */

10,

"<init>",

"(J)V" },

/*11 UnsignedInt64NewBi */

{ /*UnsignedInt64 */

11,

"<init>",

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

/*12 CIMObjectPathNewJ */

{ /*CIMObjectPath */

12,

"<init>",

"(J)V" },

/*13 CIMExceptionNewSt */

{ /*CIMException */

13,

"<init>",

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

/*14 CIMPropertyNewJ */

{ /*CIMProperty */

15,

"<init>",

"(J)V" },

/*15 VectorAddElement */

{ /*Vector */

"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[]={

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

/*00*/ { 14,

{ 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(char*)];

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

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

jmethodID instanceMethodIDs[sizeof(instanceMethodNames) /

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

sizeof(instanceMethodNames[0])];

static jclass providerClassRef;

jmethodID staticMethodIDs[sizeof(staticMethodNames) /

sizeof(staticMethodNames[0])];

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

{

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

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

jclass localRefCls=env->FindClass(name);

// if (env->ExceptionOccurred())

// env->ExceptionDescribe();

if (localRefCls == NULL)

if (localRefCls==NULL) return JNI_FALSE;

{

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

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

jmidToString);

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

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

globalRefCls,name,pszResult));

env->ReleaseStringUTFChars (jstringResult, pszResult);

#else

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

#endif

env->DeleteLocalRef(localRefCls);

PEG_METHOD_EXIT();

return globalRefCls;

}

JMPIjvm::JMPIjvm() {

JMPIjvm::JMPIjvm()

{

initJVM();

}

JMPIjvm::~JMPIjvm() {

JMPIjvm::~JMPIjvm()

{

}

int JMPIjvm::cacheIDs(JNIEnv *env)

{

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

if (methodInitDone == 1)

{

PEG_METHOD_EXIT();

return JNI_TRUE;

}

int JMPIjvm::cacheIDs(JNIEnv *env) {

if (methodInitDone == -1)

if (JMPIjvm::trace)

{

cout<<" --- cacheIDs()"<<endl;

PEG_METHOD_EXIT();

if (methodInitDone==1) return JNI_TRUE;

return JNI_FALSE;

if (methodInitDone==-1) return JNI_FALSE;

}

methodInitDone=-1;

for (unsigned i=0; i<(sizeof(classNames)/sizeof(char*)); i++) {

// cerr<<"--- Trying "<< classNames[i]<<endl;

for (unsigned i = 0; i<(sizeof(classNames)/sizeof(classNames[0])); i++)

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

{

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

{

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

PEG_METHOD_EXIT();

return JNI_FALSE;

}

unsigned instanceMethodNamesSize =

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

for (unsigned j=0; j<(sizeof(instanceMethodNames)/sizeof(METHOD_STRUCT)); j++) {

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

// cerr<<"--- Trying "<<j<<": "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<endl;

{

if ((instanceMethodIDs[j]=env->GetMethodID(

instanceMethodIDs[j] = env->GetMethodID(

classRefs[instanceMethodNames[j].clsIndex],

instanceMethodNames[j].methodName,instanceMethodNames[j].signature))==NULL) return 0;

instanceMethodNames[j].methodName,

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

instanceMethodNames[j].signature);

if (instanceMethodIDs[j] == NULL)

{

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;

}

for (unsigned k=0; k<(sizeof(staticMethodNames)/sizeof(METHOD_STRUCT)); k++) {

unsigned staticMethodNamesSize =

// cerr<<"--- Trying "<<k<<endl;

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

if ((staticMethodIDs[k]=env->GetStaticMethodID(

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

{

staticMethodIDs[k] = env->GetStaticMethodID(

classRefs[staticMethodNames[k].clsIndex],

staticMethodNames[k].methodName,staticMethodNames[k].signature))==NULL) return 0;

staticMethodNames[k].methodName,

staticMethodNames[k].signature);

if (staticMethodIDs[k] == NULL)

{

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;

}

// cerr<<"--- cacheIDs() done"<<endl;

}

if (JMPIjvm::trace)

cout<<" --- cacheIDs() ok"<<endl;

jv.env = env;

jv.classRefs = classRefs;

jv.instMethodIDs = instanceMethodIDs;

jv.staticMethodIDs = staticMethodIDs;

jv.instanceMethodNames = instanceMethodNames;

methodInitDone=1;

PEG_METHOD_EXIT();

return JNI_TRUE;

}

static void throwCIMException(JNIEnv *env,char *e) {

static void throwCIMException (JNIEnv *env, char *e)

env->ThrowNew(classRefs[13],e);

{

JMPIjvm::cacheIDs (env);

env->ThrowNew (JMPIjvm::jv.CIMExceptionClassRef, e);

}

int JMPIjvm::destroyJVM()

{

if (JMPIjvm::trace)

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

cerr<<"--- JPIjvm::destroyJVM()\n";

#ifdef JAVA_DESTROY_VM_WORKS

if (jvm!=NULL) {

if (jvm!= NULL)

{

JvmVector *jv;

attachThread(&jv);

jvm->DestroyJavaVM();

jvm=NULL;

PEG_METHOD_EXIT();

return 0;

}

#endif

PEG_METHOD_EXIT();

return -1;

}

Mutex JMPIjvm::_initMutex;

int JMPIjvm::initJVM()

{

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

AutoMutex lock (_initMutex);

if (jvm != NULL)

{

return 0;

}

JavaVMInitArgs vm_args;

JavaVMOption options[1];

jint res;

char *envcp;

char *envstring;

char classpath[1024]="-Djava.class.path=";

JNIEnv *env;

JavaVMOption *poptions = 0;

int maxoption = 0;

typedef struct _JVMOptions {

const char *pszEnvName;

const char *pszPrefix;

bool fSplit;

} JVMOPTIONS;

Array<std::string> JNIoptions;

static JVMOPTIONS aEnvOptions[] = {

{ "CLASSPATH", "-Djava.class.path=", false },

{ "PEGASUS_JMPI_MAX_HEAP", "-Xmx" , false },

{ "PEGASUS_JMPI_INITIAL_HEAP", "-Xms" , false },

{ "PEGASUS_JMPI_JAVA_THREAD_STACK_SIZE", "-Xss" , false },

{ "PEGASUS_JMPI_VERBOSE", "-verbose:" , true }

};

std::ostringstream oss;

PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"Start to initialize the JVM.");

#ifdef PEGASUS_DEBUG

if (getenv("JMPI_TRACE")) trace=1;

else trace=0;

#else

trace=0;

#endif

if (JMPIjvm::trace)

cout<<"--- JPIjvm::initJVM()\n";

jv.initRc=0;

envcp=getenv("CLASSPATH");

envstring = getenv("CLASSPATH");

if (envcp==NULL) {

if (envstring == NULL)

{

jv.initRc=1;

if (JMPIjvm::trace)

cerr<<"--- jmpiJvm::initJVM(): No PEGASUS_PROVIDER_CLASSPATH environment variable found\n";

return -1;

}

strcat(classpath,envcp);

PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,

options[0].optionString=classpath;

"No CLASSPATH environment variable found.");

vm_args.version=0x00010002;

vm_args.options=options;

vm_args.nOptions=1;

vm_args.ignoreUnrecognized=JNI_TRUE;

res=JNI_CreateJavaVM(&jvm,(void**)&env,&vm_args);

PEG_METHOD_EXIT();

if (res!=0) {

if (JMPIjvm::trace)

cerr<<"Can not create Java VM"<<endl;

exit(1);

}

jv.jvm=jvm;

jv.env=env;

if (cacheIDs(env)==1) {

throw PEGASUS_CIM_EXCEPTION_L(

jv.classRefs=classRefs;

CIM_ERR_FAILED,

jv.instMethodIDs=instanceMethodIDs;

MessageLoaderParms(

}

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

"Could not get CLASSPATH from environment.")

);

if (env->ExceptionOccurred()) {

return -1;

env->ExceptionDescribe();

exit(1);

}

return res;

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

}

///maxoption++;

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

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

JNIEnv* env;

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

if (jvm==NULL) initJVM();

{

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

JVMOPTIONS *pEnvOption = &aEnvOptions[i];

*jvp=&jv;

return env;

}

void JMPIjvm::detachThread() {

envstring = getenv(pEnvOption->pszEnvName);

jvm->DetachCurrentThread();

if (envstring)

}

{

if (pEnvOption->fSplit)

{

bool fCommaFound = true;

string stringValues = envstring;

string::size_type posStart = 0;

string::size_type posEnd = stringValues.length() - 1;

jobject JMPIjvm::getProvider(JNIEnv *env, String jar, String cln,

while (fCommaFound)

const char *cn, jclass *cls)

{

static jobject gProv=NULL;

string stringValue;

static jclass scls=NULL;

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

if (gProv) {

posStart);

*cls=scls;

return gProv;

if (posComma != string::npos)

{

fCommaFound=true;

stringValue=stringValues.substr(posStart, posComma);

posStart=posComma + 1;

}

else

{

fCommaFound=false;

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

}

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,

cout<<"--- jar: "<<jar<<endl;

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

cout<<"--- cln: "<<cln<<endl;

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

fCommaFound,posStart,posComma,posEnd));

jstring jjar=env->NewStringUTF((const char*)jar.getCString());

maxoption++;

jstring jcln=env->NewStringUTF((const char*)cln.getCString());

jclass jcls=(jclass)env->CallStaticObjectMethod(classRefs[23],staticMethodIDs[1],

oss.str ("");

jjar,jcln);

oss << pEnvOption->pszPrefix << stringValue;

if (env->ExceptionCheck()) {

env->ExceptionDescribe();

cerr<<"--- Unable to instantiate provider "<<cn<<endl;

// return NULL;

}

scls=getGlobalClassRef(env,(const char*)cln.getCString());

JNIoptions.append (oss.str ());

if (env->ExceptionCheck()) {

if (JMPIjvm::trace)

cerr<<"--- Provider "<<cn<<" not found"<<endl;

return NULL;

}

*cls=scls;

jmethodID id=env->GetMethodID(*cls,"<init>","()V");

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,

jobject lProv=env->NewObject(*cls,id);

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

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

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

if (env->ExceptionCheck()) {

if (JMPIjvm::trace)

cerr<<"--- Unable to instantiate provider "<<cn<<endl;

return NULL;

}

return gProv;

}

else

jobject JMPIjvm::getProvider(JNIEnv *env, const char *cn, jclass *cls)

{

static jobject gProv=NULL;

maxoption++;

static jclass scls=NULL;

if (gProv) {

*cls=scls;

return gProv;

}

scls=getGlobalClassRef(env,cn);

oss.str ("");

if (env->ExceptionCheck()) {

oss << pEnvOption->pszPrefix << envstring;

if (JMPIjvm::trace)

cerr<<"--- Provider "<<cn<<" not found"<<endl;

JNIoptions.append (oss.str ());

return NULL;

}

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

*cls=scls;

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

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

jmethodID id=env->GetMethodID(*cls,"<init>","()V");

jobject lProv=env->NewObject(*cls,id);

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

if (env->ExceptionCheck()) {

if (JMPIjvm::trace)

cerr<<"--- Unable to instantiate provider "<<cn<<endl;

return NULL;

}

return gProv;

}

void JMPIjvm::checkException(JNIEnv *env)

poptions = (JavaVMOption *)calloc (maxoption, sizeof (JavaVMOption));

if (!poptions)

{

jv.initRc = 1;

if (env->ExceptionCheck()) {

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,

jstring jMsg=NULL,jId=NULL;

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

int code;

maxoption,sizeof (JavaVMOption)));

const char *cp;

String msg=String::EMPTY,id=String::EMPTY;

jthrowable err=env->ExceptionOccurred();

PEG_METHOD_EXIT();

if (JMPIjvm::trace)

return -1;

env->ExceptionDescribe();

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

env->ExceptionClear();

if (err) {

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

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

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

if (jId) {

cp=env->GetStringUTFChars(jId,NULL);

id=String(cp);

env->ReleaseStringUTFChars(jId,cp);

}

if (jMsg) {

for (Uint32 i = 0; i < JNIoptions.size(); i++)

cp=env->GetStringUTFChars(jMsg,NULL);

{

msg=String(cp);

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

env->ReleaseStringUTFChars(jMsg,cp);

}

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL3,

if (JMPIjvm::trace)

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

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

i ,poptions[i].optionString));

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

}

else {

env->ExceptionDescribe();

exit(13);

}

vm_args.version = JNI_VERSION_1_2;

vm_args.options = poptions;

vm_args.nOptions = maxoption;

vm_args.ignoreUnrecognized = JNI_TRUE;

res = JNI_CreateJavaVM(&jvm,(void**)&env,&vm_args);

if (poptions)

{

free (poptions);

}

/**************************************************************************

if (res!= 0)

* name - NewPlatformString

* description - Returns a new Java string object for the specified

* platform string.

* parameters - env

* s Platform encoded string

* returns - Java string object pointer or null (0)

**************************************************************************/

jstring JMPIjvm::NewPlatformString(JNIEnv *env, char *s)

{

size_t len = strlen(s);

jv.initRc = 1;

jclass cls;

jmethodID mid;

jbyteArray ary;

NULL_CHECK0(cls = (*env).FindClass("java/lang/String"));

PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL3,

NULL_CHECK0(mid = (*env).GetMethodID(cls, "<init>", "([B)V"));

"Can not create Java VM !");

ary = (*env).NewByteArray((jsize)len);

if (ary != 0) {

PEG_METHOD_EXIT();

jstring str = 0;

return -1;

(*env).SetByteArrayRegion(ary, 0, (jsize)len,

(jbyte *)s);

if (!(*env).ExceptionOccurred()) {

str = (jstring)(*env).NewObject(cls, mid, ary);

}

(*env).DeleteLocalRef(ary);

return str;

}

return 0;

}

cacheIDs(env);

/**************************************************************************

if (env->ExceptionOccurred())

* name - NewPlatformStringArray

* description - Returns a new array of Java string objects for the specified

* array of platform strings.

* parameters - env

* strv Platform encoded string array

* strc Number of strings in strv

* returns - Java string array object pointer

**************************************************************************/

jobjectArray JMPIjvm::NewPlatformStringArray(JNIEnv *env, char **strv, int strc)

{

jarray cls;

jv.initRc = 1;

jarray ary;

int i;

NULL_CHECK0(cls = (jarray)(*env).FindClass("java/lang/String"));

NULL_CHECK0(ary = (*env).NewObjectArray(strc, (jclass)cls, 0));

for (i = 0; i < strc; i++) {

jstring str = NewPlatformString(env, *strv++);

NULL_CHECK0(str);

(*env).SetObjectArrayElement((jobjectArray)ary, i, str);

(*env).DeleteLocalRef(str);

}

return (jobjectArray)ary;

}

env->ExceptionDescribe();

#ifdef JAVA_DESTROY_VM_WORKS

JvmVector *jv = NULL;

attachThread (&jv);

extern "C" {

jvm->DestroyJavaVM ();

jvm = NULL;

#endif

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

PEG_METHOD_EXIT();

JMPIjvm::cacheIDs(jEnv);

return -1;

jobject ev=jEnv->NewObject(classRefs[13],instanceMethodIDs[18],(jint)e.getCode());

jEnv->Throw((jthrowable)ev);

}

void throwFailedException(JNIEnv *jEnv) {

jv.initRc = 1;

JMPIjvm::cacheIDs(jEnv);

jv.jvm = jvm;

jobject ev=jEnv->NewObject(classRefs[13],instanceMethodIDs[18],1);

jEnv->Throw((jthrowable)ev);

}

void throwNotSupportedException(JNIEnv *jEnv) {

PEG_METHOD_EXIT();

JMPIjvm::cacheIDs(jEnv);

return res;

jobject ev=jEnv->NewObject(classRefs[13],instanceMethodIDs[18],7);

jEnv->Throw((jthrowable)ev);

}

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

{

JNIEnv* env = NULL;

int rc;

if (jvm == NULL)

{

rc = initJVM ();

if ((jvm == NULL) || (rc != 0))

return NULL;

}

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

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

// ---

// - CIMException

// ---

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

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1new

*jvp = &jv;

(JNIEnv *jEnv, jobject jThs) {

jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[41]);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newS

return env;

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

jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[42],jM);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSO

void JMPIjvm::detachThread ()

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

{

jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[43],jM,jO1);

jvm->DetachCurrentThread ();

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSOO

jobject JMPIjvm::getProvider (JNIEnv *env,

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

String jarName,

jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[44],jM,jO1,jO2);

String className,

}

const char *pszProviderName,

jclass *pjClass)

{

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

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSOOO

jobject jProviderInstance = 0;

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

jclass jClassLoaded = 0;

jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[45],jM,jO1,jO2,jO3);

jmethodID jId = 0;

jobject jProviderInstanceLocal = 0;

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

(const char*)jarName.getCString(),

(const char*)className.getCString(),

pszProviderName,pjClass));

// CASE #1

// className has been loaded previously.

// Return saved instance.

_objectTable.lookup (className, jProviderInstance);

_classTable.lookup (className, jClassLoaded);

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

jProviderInstance,jClassLoaded));

if ( jProviderInstance

&& jClassLoaded

)

{

if (pjClass)

{

*pjClass = jClassLoaded;

}

PEG_METHOD_EXIT();

return jProviderInstance;

}

// CASE #2

// className can be loaded via getGlobalClassRef ().

// Load and return the instance.

// NOTE:

// According to

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

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

jClassLoaded = getGlobalClassRef (env,

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

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

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

// ---

"jClassLoaded = %p",jClassLoaded));

// - CIMOMHandle

// ---

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

CIMPropertyList getList(JNIEnv *jEnv, jobjectArray l) {

if (env->ExceptionCheck ())

CIMPropertyList pl;

{

if (l) {

// CASE #3

Array<CIMName> n;

// see if the className can be loaded via JarClassLoader.load ().

for (jsize i=0,s=jEnv->GetArrayLength(l); i<s; i++) {

// Load and return the instance.

jstring jObj=(jstring)jEnv->GetObjectArrayElement(l,i);

jstring jJarName = 0;

const char *pn=jEnv->GetStringUTFChars(jObj,NULL);

jstring jClassName = 0;

n.append(pn);

jclass jClassLoadedLocal = 0;

jEnv->ReleaseStringUTFChars(jObj,pn);

}

env->ExceptionClear ();

pl.set(n);

// NOTE: Instances of "packageName/className" will not work with the jar

// class loader. Change the '/' to a '.'.

String fixedClassName;

Uint32 idx = className.find ('/');

if (idx != PEG_NOT_FOUND)

{

fixedClassName = className.subString (0, idx)

+ "."

+ className.subString (idx + 1);

}

return pl;

else

{

fixedClassName = className;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getClass

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

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

jboolean iq, jboolean ic, jobjectArray jPl) {

CIMOMHandle *ch=(CIMOMHandle*)jCh;

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

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

CIMPropertyList pl;

OperationContext ctx;

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

if (jPl) pl=getList(jEnv,jPl);

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

else pl=CIMPropertyList();

jJarName,jClassName));

try {

CIMClass cls=ch->getClass(ctx,cop->getNameSpace(),cop->getClassName(),(Boolean)lo,

jClassLoadedLocal = (jclass)env->CallStaticObjectMethod(

(Boolean)iq,(Boolean)ic,pl);

JMPIjvm::jv.JarClassLoaderClassRef,

return (jint) new CIMClass(cls);

JMPIjvm::jv.JarClassLoaderLoad,

}

jJarName,

Catch(jEnv);

jClassName);

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"jClassLoadedLocal = %p",jClassLoadedLocal));

if (env->ExceptionCheck ())

{

env->ExceptionDescribe();

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,

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

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createClass

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

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

CIMObjectPath *cop=(CIMObjectPath*)jCop;

"jClassLoaded = %p",jClassLoaded));

CIMClass *cl=(CIMClass*)jCl;

OperationContext ctx;

env->DeleteLocalRef (jClassLoadedLocal);

try {

ch->createClass(ctx,cop->getNameSpace(),*cl);

}

Catch(jEnv);

return;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setClass

if (pjClass)

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

{

CIMOMHandle *ch=(CIMOMHandle*)jCh;

*pjClass = jClassLoaded;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMClass *cl=(CIMClass*)jCl;

OperationContext ctx;

try {

ch->modifyClass(ctx,cop->getNameSpace(),*cl);

}

Catch(jEnv);

return ;

if (!jClassLoaded)

{

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"Unable to instantiate provider %s: "

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

PEG_METHOD_EXIT();

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteClass

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

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

OperationContext ctx;

try {

jProviderInstanceLocal = env->NewObject (jClassLoaded,

ch->deleteClass(ctx,cop->getNameSpace(),cop->getClassName());

jId);

}

Catch(jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClassNames

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

"NewObject() jProviderInstanceLocal = %p ",

CIMOMHandle *ch=(CIMOMHandle*)jCh;

jProviderInstanceLocal));

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMNamespaceName ns=cop->getNameSpace();

if (!jProviderInstanceLocal)

OperationContext ctx;

{

try {

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,

Array<CIMName> enm=ch->enumerateClassNames(ctx,cop->getNameSpace(),cop->getClassName(),deep);

"Unable to instantiate provider %s: "

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

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

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

PEG_METHOD_EXIT();

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

}

return (jint)enmop;

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClasses

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

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

jboolean lo, jboolean iq, jboolean ic) {

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

CIMOMHandle *ch=(CIMOMHandle*)jCh;

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

CIMObjectPath *cop=(CIMObjectPath*)jCop;

OperationContext ctx;

if (!jProviderInstance)

try {

{

Array<CIMClass> en=ch->enumerateClasses(ctx,cop->getNameSpace(),cop->getClassName(),

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,

deep,(Boolean)lo,iq,ic);

"Unable to instantiate provider %s: "

return (jint) new Array<CIMClass>(en);

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

}

PEG_METHOD_EXIT();

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getInstance

_classTable.insert (className, jClassLoaded);

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

_objectTable.insert (className, jProviderInstance);

jobjectArray jPl) {

CIMOMHandle *ch=(CIMOMHandle*)jCh;

PEG_METHOD_EXIT();

CIMObjectPath *cop=(CIMObjectPath*)jCop;

return jProviderInstance;

OperationContext ctx;

CIMPropertyList pl;

if (jPl) pl=getList(jEnv,jPl);

else pl=CIMPropertyList();

try {

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

(Boolean)lo,(Boolean)iq,(Boolean)ic,pl));

return (jint)(void*)inst;

}

Catch(jEnv);

return -1;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance

jobject JMPIjvm::getProvider (JNIEnv *env, const char *cn, jclass *cls)

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

{

String cln = cn;

jobject gProv = NULL;

jclass scls = NULL;

CIMOMHandle *ch=(CIMOMHandle*)jCh;

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

CIMObjectPath *cop=(CIMObjectPath*)jCop;

OperationContext ctx;

try {

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

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

}

Catch(jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createInstance

_objectTable.lookup(cln,gProv);

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

_classTable.lookup(cln,scls);

CIMOMHandle *ch=(CIMOMHandle*)jCh;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMInstance *ci=(CIMInstance*)jCi;

OperationContext ctx;

try {

ci->setPath(*cop);

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

return (jint) new CIMObjectPath(obj);

}

Catch(jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1modifyInstance

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

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

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

jboolean iq, jobjectArray jPl) {

CIMOMHandle *ch=(CIMOMHandle*)jCh;

if (gProv)

CIMObjectPath *cop=(CIMObjectPath*)jCop;

{

CIMInstance *ci=(CIMInstance*)jCi;

*cls = scls;

CIMPropertyList pl=getList(jEnv,jPl);

return gProv;

OperationContext ctx;

try {

ci->setPath(*cop);

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

}

Catch(jEnv);

return ;

scls = getGlobalClassRef(env,cn);

if (env->ExceptionCheck())

{

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,

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

PEG_METHOD_EXIT();

return NULL;

}

*cls = scls;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstanceNames

if (scls)

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

{

CIMOMHandle *ch=(CIMOMHandle*)jCh;

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

OperationContext ctx;

_classTable.insert(cln,scls);

try {

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

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

return (jint) new Array<CIMObjectPath>(enm);

}

Catch(jEnv);

return 0;

jmethodID id = env->GetMethodID(*cls,"<init>","()V");

jobject lProv = env->NewObject(*cls,id);

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

if (env->ExceptionCheck())

{

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,

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

PEG_METHOD_EXIT();

return NULL;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstances

if (gProv)

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

{

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

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

CIMOMHandle *ch=(CIMOMHandle*)jCh;

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

CIMObjectPath *cop=(CIMObjectPath*)jCop;

_objectTable.insert(cln,gProv);

CIMPropertyList pl;

OperationContext ctx;

if (jPl) pl=getList(jEnv,jPl);

else pl=CIMPropertyList();

try {

Array<CIMInstance> en=ch->enumerateInstances(ctx,cop->getNameSpace(),cop->getClassName(),

deep,lo,iq,ic,pl);

return (jint) new Array<CIMInstance>(en);

}

Catch(jEnv);

return 0;

PEG_METHOD_EXIT();

return gProv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1execQuery

#if 0

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

OperationContext ctx;

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

// Java 1.4 version of programmatically accessting the backtrace stack

String query(str);

// NOTE: Renumber to follow current content

jEnv->ReleaseStringUTFChars(jQuery,str);

// add to:

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

// const char* classNames[]={

String ql(str);

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

jEnv->ReleaseStringUTFChars(jQl,str);

// 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;" }

try {

String getExceptionInfo (JNIEnv *env)

Array<CIMObject> enm=ch->execQuery(ctx,cop->getNameSpace(),query,ql);

{

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

jthrowable err = env->ExceptionOccurred ();

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

jobjectArray stackTrace = 0;

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

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;

}

return (jint)enmInst;

stackTrace = (jobjectArray)env->CallObjectMethod(

err,

JMPIjvm::jv.ThrowableGetStackTrace);

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"stackTrace = %p ",stackTrace));

if (!stackTrace)

{

PEG_METHOD_EXIT();

return rc;

}

Catch(jEnv);

return 0;

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getProperty

std::ostringstream oss;

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

String exceptionInfo;

CIMOMHandle *ch=(CIMOMHandle*)jCh;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

OperationContext ctx;

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

try {

if (pszFile)

CIMName prop(str);

{

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

oss << "File: " << pszFile;

jEnv->ReleaseStringUTFChars(jN,str);

return (jint)(void*)cv;

env->ReleaseStringUTFChars (jFile, pszFile);

}

Catch(jEnv);

if (jLine)

return -1;

{

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

}

if (pszClass)

{

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

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setProperty

env->ReleaseStringUTFChars (jClass, pszClass);

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

OperationContext ctx;

CIMValue *val=(CIMValue*)jCop;

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

CIMName pName(str);

jEnv->ReleaseStringUTFChars(jPn,str);

try {

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

}

Catch(jEnv);

if (pszMethod)

return;

{

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;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod

#else

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

OperationContext ctx;

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

CIMName method(str);

jEnv->ReleaseStringUTFChars(jMn,str);

Array<CIMParamValue> in;

String getExceptionInfo (JNIEnv *env)

Array<CIMParamValue> out;

{

jthrowable err = env->ExceptionOccurred ();

String rc;

for (int i=0,m=jEnv->CallIntMethod(jIn,instanceMethodIDs[28]); i<m; i++) {

PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,"getExceptionInfo");

JMPIjvm::checkException(jEnv);

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

JMPIjvm::checkException(jEnv);

CIMProperty *p=((CIMProperty*)jEnv->CallIntMethod(jProp,instanceMethodIDs[29]));

JMPIjvm::checkException(jEnv);

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

}

try {

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

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

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

const CIMParamValue & parm=out[i];

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

const CIMValue v=parm.getValue();

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

if (!err)

jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)p);

{

jEnv->CallVoidMethod(jOut,instanceMethodIDs[15],prop);

PEG_METHOD_EXIT();

}

return rc;

return (jint)val;

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod24

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

jobjectArray jIn, jobjectArray jOut) {

CIMOMHandle *ch=(CIMOMHandle*)jCh;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

OperationContext ctx;

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

CIMName method(str);

jEnv->ReleaseStringUTFChars(jMn,str);

Array<CIMParamValue> in;

// ByteArrayOutputStream baos = new ByteArrayOutputStream ();

Array<CIMParamValue> out;

// PrintStream ps = new PrintStream (baos);

// e.printStackTrace (ps);

// result = baos.toString ();

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

jobject jBAOS = 0;

JMPIjvm::checkException(jEnv);

jobject jPS = 0;

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

JMPIjvm::checkException(jEnv);

CIMParamValue *p=((CIMParamValue*)jEnv->CallIntMethod(jArg,instanceMethodIDs[39]));

JMPIjvm::checkException(jEnv);

in.append(*p);

}

try {

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

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

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

const CIMParamValue & parm=out[i];

JMPIjvm::jv.ByteArrayOutputStreamNew);

jEnv->SetObjectArrayElement(jOut,i,

jEnv->NewObject(classRefs[29],instanceMethodIDs[40],(jint)&parm));

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

}

return (jint)val;

if (!jBAOS)

{

env->ExceptionDescribe ();

PEG_METHOD_EXIT();

return rc;

}

Catch(jEnv);

return 0;

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;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associatorNames

jST = (jstring)env->CallObjectMethod(

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

jBAOS,

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

JMPIjvm::jv.ByteArrayOutputStreamToString);

CIMOMHandle *ch=(CIMOMHandle*)jCh;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

OperationContext ctx;

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

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

CIMName assocClass(str);

jEnv->ReleaseStringUTFChars(jAssocClass,str);

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

CIMName resultClass(str);

jEnv->ReleaseStringUTFChars(jResultClass,str);

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

String role(str);

jEnv->ReleaseStringUTFChars(jRole,str);

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

String resultRole(str);

jEnv->ReleaseStringUTFChars(jResultRole,str);

try {

const char *pszST = 0;

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

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

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

return (jint) new Array<CIMObjectPath>(enm);

if (pszST)

{

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"pszST = %s ",pszST));

rc = pszST;

env->ReleaseStringUTFChars (jST, pszST);

}

Catch(jEnv);

return 0;

PEG_METHOD_EXIT();

return rc;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIM__1associators

#endif

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

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

void JMPIjvm::checkException (JNIEnv *env)

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl) {

{

CIMOMHandle *ch=(CIMOMHandle*)jCh;

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

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMPropertyList pl=getList(jEnv,jPl);

if (!env->ExceptionCheck ())

OperationContext ctx;

{

PEG_METHOD_EXIT();

return;

}

jstring jMsg = NULL,

jId = NULL;

int code;

const char *cp;

String msg;

String id;

jthrowable err = env->ExceptionOccurred ();

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

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

if (!err)

{

PEG_METHOD_EXIT();

return;

}

PEG_TRACE_CSTRING(TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"Provider caused an exception!");

env->ExceptionDescribe ();

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

{

env->ExceptionClear ();

jMsg = (jstring)env->CallObjectMethod(

err,

JMPIjvm::jv.ThrowableGetMessage);

code = (int)env->CallIntMethod(

err,

JMPIjvm::jv.CIMExceptionGetCode);

jId = (jstring)env->CallObjectMethod(

err,

JMPIjvm::jv.CIMExceptionGetID);

if (jId)

{

cp = env->GetStringUTFChars (jId, NULL);

id = String (cp);

env->ReleaseStringUTFChars (jId, cp);

}

if (jMsg)

{

cp = env->GetStringUTFChars (jMsg, NULL);

msg = String (cp);

env->ReleaseStringUTFChars (jMsg, cp);

}

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,

"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

{

String info = getExceptionInfo (env);

env->ExceptionClear ();

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL2,

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

}

/**************************************************************************

* name - NewPlatformString

* description - Returns a new Java string object for the specified

* platform string.

* parameters - env

* s Platform encoded string

* returns - Java string object pointer or null (0)

**************************************************************************/

jstring JMPIjvm::NewPlatformString (JNIEnv *env, char *s)

{

size_t len = strlen(s);

jclass cls;

jmethodID mid;

jbyteArray ary;

NULL_CHECK0(cls = (*env).FindClass("java/lang/String"));

NULL_CHECK0(mid = (*env).GetMethodID(cls, "<init>", "([B)V"));

ary = (*env).NewByteArray((jsize)len);

if (ary != 0)

{

jstring str = 0;

(*env).SetByteArrayRegion (ary,

(jsize)len,

(jbyte *)s);

if (!(*env).ExceptionOccurred ())

{

str = (jstring)(*env).NewObject (cls, mid, ary);

}

(*env).DeleteLocalRef (ary);

return str;

}

return 0;

}

/**************************************************************************

* name - NewPlatformStringArray

* description - Returns a new array of Java string objects for the specified

* array of platform strings.

* parameters - env

* strv Platform encoded string array

* strc Number of strings in strv

* returns - Java string array object pointer

**************************************************************************/

jobjectArray JMPIjvm::NewPlatformStringArray(JNIEnv *env, char **strv, int strc)

{

jarray cls;

jarray ary;

int i;

NULL_CHECK0(cls = (jarray)(*env).FindClass("java/lang/String"));

NULL_CHECK0(ary = (*env).NewObjectArray(strc, (jclass)cls, 0));

for(i = 0; i < strc; i++)

{

jstring str = NewPlatformString (env, *strv++);

NULL_CHECK0(str);

(*env).SetObjectArrayElement ((jobjectArray)ary, i, str);

(*env).DeleteLocalRef (str);

}

return (jobjectArray)ary;

}

CIMPropertyList getList (JNIEnv *jEnv, jobjectArray l)

{

CIMPropertyList pl;

if (l)

{

Array<CIMName> n;

for (jsize i = 0, s = jEnv->GetArrayLength (l); i <s; i++)

{

jstring jObj = (jstring)jEnv->GetObjectArrayElement (l, i);

const char *pn = jEnv->GetStringUTFChars (jObj, NULL);

n.append (pn);

jEnv->ReleaseStringUTFChars (jObj, pn);

}

pl.set (n);

}

return pl;

}

extern "C" {

void throwCimException (JNIEnv *jEnv, CIMException &e)

{

JMPIjvm::cacheIDs(jEnv);

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

jEnv->Throw((jthrowable)ev);

}

void throwNotSupportedException (JNIEnv *jEnv)

{

JMPIjvm::cacheIDs(jEnv);

jobject ev = jEnv->NewObject(

JMPIjvm::jv.CIMExceptionClassRef,

JMPIjvm::jv.CIMExceptionNewI,

7);

jEnv->Throw((jthrowable)ev);

}

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

// ---

// - CIMArgument

// ---

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

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1new

(JNIEnv *jEnv, jobject jThs)

{

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

return DEBUG_ConvertCToJava (CIMParamValue*, jlong, p);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1newS

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

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

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

jEnv->ReleaseStringUTFChars (jN, str);

return DEBUG_ConvertCToJava (CIMParamValue*, jlong, p);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1newSV

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

{

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

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

CIMParamValue *p = 0;

if ( str

&& cv

)

{

p = new CIMParamValue (str, *cv);

}

jEnv->ReleaseStringUTFChars (jN, str);

return DEBUG_ConvertCToJava (CIMParamValue*, jlong, p);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1getType

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

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

const CIMValue cv = cp->getValue ();

String ref;

bool fSuccess = false;

int iJType = 0;

_dataType *type = 0;

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

if (fSuccess)

{

type = new _dataType (iJType,

cv.getArraySize (),

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

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1getValue

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

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

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

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

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_CIMArgument__1setName

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

{

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

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

String n (str);

cp->setParameterName (n);

jEnv->ReleaseStringUTFChars (jN, str);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

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

delete cp;

DEBUG_ConvertCleanup (jlong, jP);

}

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

// ---

// - CIMClass

// ---

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

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1newInstance

(JNIEnv *jEnv, jobject jThs, jlong jCls)

{

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

if (cls)

{

try

{

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

{

}

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

{

CIMProperty cp = cls->getProperty (i);

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

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

{

try

{

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

}

catch (Exception e)

{

}

return DEBUG_ConvertCToJava (CIMInstance*, jlong, ci);

}

Catch (jEnv);

}

return 0;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1filterProperties

(JNIEnv *jEnv,

jobject jThs,

jlong jInst,

jobjectArray jPl,

jboolean iq,

jboolean ic,

jboolean lo)

{

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

CIMClass *cf = 0;

CIMName clsn = cc->getClassName ();

if (lo)

{

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

CIMName clsn = cc->getClassName ();

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

{

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

cf->removeProperty (i);

}

return DEBUG_ConvertCToJava (CIMClass*, jlong, cf);

}

else if (jPl)

{

CIMPropertyList pl = getList (jEnv,jPl);

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

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

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

{

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

if (pos != PEG_NOT_FOUND)

{

if (iq)

{

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

if (!ic)

cp.setClassOrigin (CIMName ());

cf->addProperty (cp);

}

else

{

CIMProperty cp = cc->getProperty (pos);

CIMName co;

if (ic)

co = cp.getClassOrigin ();

CIMProperty np (cp.getName (),

cp.getValue (),

cp.getArraySize (),

cp.getReferenceClassName (),

co,

cp.getPropagated ());

cf->addProperty (np);

}

if (iq)

{

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

{

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

}

else if (iq)

{

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

if (ic)

return DEBUG_ConvertCToJava (CIMClass*, jlong, cf);

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

{

CIMProperty cp = cf->getProperty (i);

cp.setClassOrigin (CIMName ());

cf->removeProperty (i);

cf->addProperty (cp);

}

else

{

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

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

{

CIMProperty cp = cc->getProperty (i);

CIMName co;

if (ic)

co = cp.getClassOrigin ();

CIMProperty np (cp.getName (),

cp.getValue (),

cp.getArraySize (),

cp.getReferenceClassName (),

co,

cp.getPropagated ());

cf->addProperty (np);

}

return DEBUG_ConvertCToJava (CIMClass*, jlong, cf);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getName

(JNIEnv *jEnv, jobject jThs, jlong jCls)

{

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

try {

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

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

return str;

}

Catch (jEnv);

return 0;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifier

(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->findQualifier (String (str));

if (pos != PEG_NOT_FOUND)

rv = DEBUG_ConvertCToJava (CIMQualifier*,

jlong,

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

jEnv->ReleaseStringUTFChars (jN, str);

return rv;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifiers

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

{

JMPIjvm::cacheIDs (jEnv);

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

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

{

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

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

jobject qual = jEnv->NewObject(

JMPIjvm::jv.CIMQualifierClassRef,

JMPIjvm::jv.CIMQualifierNewJ,

jCq);

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

}

return jVec;

}

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 (jQ,str);

return (jboolean)(pos != PEG_NOT_FOUND);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1addProperty

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

{

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

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

try

{

cls->addProperty (*p);

}

Catch (jEnv);

}

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

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

{

cls->removeProperty (i);

}

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

jVec,

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

{

JMPIjvm::checkException (jEnv);

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

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

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

JMPIjvm::checkException (jEnv);

cls->addProperty (*cp);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperty

(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->findProperty (CIMName (str));

if (pos != PEG_NOT_FOUND)

rv = DEBUG_ConvertCToJava (CIMProperty*,

jlong,

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

jEnv->ReleaseStringUTFChars (jN,str);

return rv;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties

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

{

JMPIjvm::cacheIDs (jEnv);

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

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

{

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

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

}

return jVec;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1new

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

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

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

jEnv->ReleaseStringUTFChars (jN,str);

return DEBUG_ConvertCToJava (CIMClass*, jlong, cls);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getSuperClass

(JNIEnv *jEnv, jobject jThs, jlong jCls)

{

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

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

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

return str;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getKeys

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

{

JMPIjvm::cacheIDs (jEnv);

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

if (cls->hasKeys ())

{

Array<CIMName> keyNames;

cls->getKeyNames (keyNames);

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

{

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

if (pos != PEG_NOT_FOUND)

{

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

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

jobject prop = jEnv->NewObject(

JMPIjvm::jv.CIMPropertyClassRef,

JMPIjvm::jv.CIMPropertyNewJ,

jCp);

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

}

return jVec;

}

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

if (pos != PEG_NOT_FOUND)

{

rv = DEBUG_ConvertCToJava(

CIMMethod*,

jlong,

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

}

jEnv->ReleaseStringUTFChars (jN,str);

return rv;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1equals

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

{

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

CIMClass *clsToBeCompared = DEBUG_ConvertJavaToC(

jlong,

CIMClass*,

jClsToBeCompared);

bool fRc = false;

if ( cls && clsToBeCompared )

{

try

{

fRc = cls->identical (*clsToBeCompared);

}

Catch (jEnv);

}

return fRc;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1isAssociation

(JNIEnv *jEnv, jobject jThs, jlong jCls)

{

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

jboolean rv = false;

if (cls)

{

try

{

rv = cls->isAssociation ();

}

Catch (jEnv);

}

return rv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1findMethod

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

{

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

jint rv = -1;

if (cls)

{

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

try

{

CIMName name (cstrName);

rv = cls->findMethod (name);

}

Catch (jEnv);

jEnv->ReleaseStringUTFChars (jName, cstrName);

}

return rv;

}

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 (cls && jMethod >=0)

{

try

{

CIMMethod cm = cls->getMethod (jMethod);

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

}

Catch (jEnv);

}

return rv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethodCount

(JNIEnv *jEnv, jobject jThs, jlong jCls)

{

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

jint rv = 0;

if (cls)

{

try

{

rv = cls->getMethodCount ();

}

Catch (jEnv);

}

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

}

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

// ---

// - CIMClient

// ---

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

void checkNs (CIMObjectPath *cop, jlong jNs)

{

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

{

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

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

}

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

{

Uint32 n = ns.size ();

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

{

if (n >= 2)

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

}

lastNsComp = ns;

nsBase = "root";

n = ns.reverseFind ('/');

if (n != PEG_NOT_FOUND)

{

lastNsComp = ns.subString (n+1);

nsBase = ns.subString (0, n);

}

return 0;

}

Boolean verifyServerCertificate (SSLCertificateInfo &certInfo)

{

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

{

return true;

}

else

{

return false;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1newNaUnPw

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

{

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

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

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

jlong jCc = 0;

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

#ifdef PEGASUS_HAS_SSL

if (cNs->isHttps ())

{

try

{

sslContext = new SSLContext (PEGASUS_SSLCLIENT_CERTIFICATEFILE,

verifyServerCertificate,

PEGASUS_SSLCLIENT_RANDOMFILE);

}

catch (Exception &e)

{

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

<< e.getMessage() << endl;

return jCc;

}

#endif

try {

CIMClient *cc = new CIMClient ();

if (sslContext)

{

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

}

else

{

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

}

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

}

Catch (jEnv);

jEnv->ReleaseStringUTFChars (jUn, un);

jEnv->ReleaseStringUTFChars (jPw, pw);

delete sslContext;

return jCc;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1disconnect

(JNIEnv *jEnv, jobject jThs, jlong jCc)

{

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

try {

cCc->disconnect ();

}

Catch (jEnv);

}

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 {

checkNs (cop, jNs);

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

cop->getClassName (),

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,

pl);

CIMObjectPath copNew = cls.getPath ();

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

cls.setPath (copNew);

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

}

Catch (jEnv);

}

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteClass

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

checkNs (cop, jNs);

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

cop->getClassName ());

}

Catch (jEnv);

}

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

try {

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

}

Catch (jEnv);

}

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

try {

checkNs (cop, jNs);

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

}

Catch (jEnv);

}

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 {

checkNs (cop, jNs);

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

*cop,

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,

pl);

inst.setPath (*cop);

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

}

Catch (jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteInstance

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

checkNs (cop, jNs);

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

}

Catch (jEnv);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1createInstance

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

{

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

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

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

try {

checkNs (cop, jNs);

ci->setPath (*cop);

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

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

}

Catch (jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1modifyInstance

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

jboolean iq, jobjectArray jPl)

{

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

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

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

CIMPropertyList pl = getList (jEnv, jPl);

try {

checkNs (cop, jNs);

ci->setPath (*cop);

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

}

Catch (jEnv);

}

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

try {

checkNs (cop, jNs);

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

cop->getClassName (),

(Boolean)deep,

(Boolean)lo,

(Boolean)iq,

(Boolean)ic);

return DEBUG_ConvertCToJava(

Array<CIMClass>*,

jlong,

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)

{

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

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

CIMNamespaceName ns = cop->getNameSpace ();

try {

checkNs (cop, jNs);

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

cop->getClassName(),

(Boolean)deep);

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

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

{

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

}

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

}

Catch (jEnv);

return 0;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstanceNames

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

{

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

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

try {

checkNs (cop,jNs);

Array<CIMObjectPath> enm = cCc->enumerateInstanceNames(

cop->getNameSpace(),

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

return DEBUG_ConvertCToJava(

Array<CIMObjectPath>*,

jlong,

new Array<CIMObjectPath> (enm));

}

Catch (jEnv);

return 0;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstances(

JNIEnv *jEnv,

jobject jThs,

jlong jCc,

jlong jNs,

jlong jCop,

jboolean deep,

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 {

checkNs (cop, jNs);

CIMPropertyList props;

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

cop->getClassName (),

(Boolean)deep,

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,pl);

return DEBUG_ConvertCToJava(

Array<CIMInstance>*,

jlong,

new Array<CIMInstance> (enm));

}

Catch (jEnv);

return 0;

}

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 {

checkNs (cop, jNs);

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

return DEBUG_ConvertCToJava(

Array<CIMQualifierDecl>*,

jlong,

new Array<CIMQualifierDecl> (enm));

}

Catch (jEnv);

return 0;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1getQualifier

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

{

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

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

try {

checkNs (cop,jNs);

CIMQualifierDecl *val = new CIMQualifierDecl(

cCc->getQualifier(

cop->getNameSpace (),

cop->getClassName ()));

return DEBUG_ConvertCToJava (CIMQualifierDecl*, jlong, val);

}

Catch (jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setQualifier

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

{

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

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

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

try {

checkNs (cop, jNs);

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

}

Catch (jEnv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteQualifier

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

checkNs (cop, jNs);

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

}

Catch (jEnv);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty

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

{

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

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

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

CIMName pName (str);

jlong jCv = 0;

try {

checkNs (cop, jNs);

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

cop->getNameSpace(),

*cop,

pName));

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

}

Catch (jEnv);

jEnv->ReleaseStringUTFChars (jPn, str);

return jCv;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty(

JNIEnv *jEnv,

jobject jThs,

jlong jCc,

jlong jNs,

jlong jCop,

jstring jPn,

jlong jV)

{

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

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

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

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

CIMName pName (str);

try {

checkNs (cop,jNs);

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

}

Catch (jEnv);

jEnv->ReleaseStringUTFChars (jPn, str);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery(

JNIEnv *jEnv,

jobject jThs,

jlong jCc,

jlong jNs,

jlong jCop,

jstring jQuery,

jstring jQl)

{

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

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

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

String query (str);

jEnv->ReleaseStringUTFChars (jQuery, str);

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

String ql (str);

jEnv->ReleaseStringUTFChars (jQl, str);

try {

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

{

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

}

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

}

Catch (jEnv);

return 0;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod(

JNIEnv *jEnv,

jobject jThs,

jlong jCc,

jlong jNs,

jlong jCop,

jstring jMn,

jobject jIn,

jobject jOut)

{

JMPIjvm::cacheIDs (jEnv);

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 = 0,m = jEnv->CallIntMethod(jIn,JMPIjvm::jv.VectorSize); i<m; i++)

{

JMPIjvm::checkException (jEnv);

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

JMPIjvm::checkException (jEnv);

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

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

JMPIjvm::checkException (jEnv);

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

}

try {

checkNs (cop, jNs);

CIMValue *val = new CIMValue(

cCc->invokeMethod(

cop->getNameSpace(),

*cop,

method,

in,

out));

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

{

const CIMParamValue &parm = out[i];

const CIMValue v = parm.getValue ();

CIMProperty *p = new CIMProperty(

parm.getParameterName(),

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

}

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

}

Catch (jEnv);

jEnv->ReleaseStringUTFChars (jMn,str);

return jCv;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod24

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

jobjectArray jIn, jobjectArray jOut)

{

JMPIjvm::cacheIDs (jEnv);

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

{

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

{

JMPIjvm::checkException (jEnv);

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

JMPIjvm::checkException (jEnv);

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

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

JMPIjvm::checkException (jEnv);

in.append (*p);

}

try {

checkNs (cop,jNs);

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

*cop,

method,

in,

out));

if (jOut)

{

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

{

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 (jMn, str);

return jCv;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1associatorNames(

JNIEnv *jEnv,

jobject jThs,

jlong jCc,

jlong jNs,

jlong jCop,

jstring jAssocClass,

jstring jResultClass,

jstring jRole,

jstring jResultRole)

{

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

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

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

CIMName assocClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

else

{

jobject ev = jEnv->NewObject(

JMPIjvm::jv.CIMExceptionClassRef,

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF(

"Invalid association class name"));

jEnv->Throw ((jthrowable)ev);

return 0;

}

jEnv->ReleaseStringUTFChars (jAssocClass,str);

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

CIMName resultClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

resultClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF(

"Invalid result class name"));

jEnv->Throw ((jthrowable)ev);

return 0;

}

jEnv->ReleaseStringUTFChars (jResultClass, str);

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

String role (str);

jEnv->ReleaseStringUTFChars (jRole, str);

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

String resultRole (str);

jEnv->ReleaseStringUTFChars (jResultRole, str);

try {

checkNs (cop,jNs);

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

*cop,

assocClass,

resultClass,

role,

resultRole);

return DEBUG_ConvertCToJava(

Array<CIMObjectPath>*,

jlong,

new Array<CIMObjectPath> (enm));

}

Catch (jEnv);

return 0;

}

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)

{

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

CIMName assocClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF(

"Invalid association class name"));

jEnv->Throw ((jthrowable)ev);

return 0;

}

jEnv->ReleaseStringUTFChars (jAssocClass, str);

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

CIMName resultClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

resultClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF(

"Invalid result class name"));

jEnv->Throw ((jthrowable)ev);

return 0;

}

jEnv->ReleaseStringUTFChars (jResultClass, str);

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

CIMName assocClass(str);

jEnv->ReleaseStringUTFChars(jAssocClass,str);

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

CIMName resultClass(str);

jEnv->ReleaseStringUTFChars(jResultClass,str);

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

String role(str);

jEnv->ReleaseStringUTFChars(jRole,str);

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

String resultRole(str);

jEnv->ReleaseStringUTFChars(jResultRole,str);

try {

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

checkNs (cop, jNs);

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

(Boolean)includeQualifiers,(Boolean)includeClassOrigin,pl);

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

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

*cop,

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

assocClass,

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

resultClass,

role,

resultRole,

(Boolean)includeQualifiers,

(Boolean)includeClassOrigin,

pl);

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

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

{

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

}

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

}

Catch (jEnv);

return 0;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1referenceNames

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

jstring jAssocClass, jstring jRole)

{

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

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

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

CIMName assocClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF(

"Invalid association class name"));

jEnv->Throw ((jthrowable)ev);

return 0;

}

jEnv->ReleaseStringUTFChars (jAssocClass, str);

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

String role (str);

jEnv->ReleaseStringUTFChars (jRole, str);

try {

checkNs (cop, jNs);

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

*cop,

assocClass,

role);

return DEBUG_ConvertCToJava(

Array<CIMObjectPath>*,

jlong,

new Array<CIMObjectPath> (enm));

}

Catch (jEnv);

return 0;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1references

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

jstring jAssocClass, jstring jRole,

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)

{

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

CIMName assocClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF(

"Invalid association class name"));

jEnv->Throw ((jthrowable)ev);

return 0;

}

jEnv->ReleaseStringUTFChars (jAssocClass, str);

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

String role (str);

jEnv->ReleaseStringUTFChars (jRole, str);

try {

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

}

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

}

Catch (jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createNameSpace

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

{

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

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

String ns (str);

jEnv->ReleaseStringUTFChars (jNs, str);

String lastNsComp;

String nsBase;

normalizeNs (ns, nsBase, lastNsComp);

CIMInstance newInstance (CIMName ("__Namespace"));

newInstance.addProperty (CIMProperty (CIMName ("name"), lastNsComp));

try {

cCc->createInstance (CIMNamespaceName (nsBase), newInstance);

}

Catch (jEnv);

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateNameSpaces(

JNIEnv *jEnv,

jobject jThs,

jlong jCc,

jlong jCop,

jboolean deep,

jobject jVec)

{

JMPIjvm::cacheIDs (jEnv);

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

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

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

try {

Array<CIMObjectPath> enm = cCc->enumerateInstanceNames(

cop->getNameSpace(),

CIMName("__Namespace"));

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

{

CIMObjectPath& cop = enm[i];

const Array<CIMKeyBinding>& kb = cop.getKeyBindings ();

const String& n = kb[0].getValue ();

if (!deep && n.find ('/') != PEG_NOT_FOUND)

continue;

String x = ns+"/"+n;

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

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

}

Catch (jEnv);

return jVec;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteNameSpace

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

{

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

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

String ns (str);

jEnv->ReleaseStringUTFChars (jNs,str);

String lastNsComp;

String nsBase;

normalizeNs (ns,nsBase,lastNsComp);

CIMObjectPath cop (String::EMPTY,

CIMNamespaceName (nsBase),

CIMName ("__Namespace"));

Array<CIMKeyBinding> kb;

kb.append (CIMKeyBinding (("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)

{

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

delete cCc;

DEBUG_ConvertCleanup (jlong, jCc);

}

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

// ---

// - CIMDataType

// ---

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

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDataType__1new

(JNIEnv *jEnv, jobject jThs, jint type)

{

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)

{

return DEBUG_ConvertCToJava (_dataType*, jlong, new _dataType (type,size));

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDataType__1newRef

(JNIEnv *jEnv, jobject jThs, jint type, jstring jRef)

{

const char *ref = jEnv->GetStringUTFChars (jRef,NULL);

jlong cInst = DEBUG_ConvertCToJava(

_dataType*,

jlong,

new _dataType(type,String (ref)));

jEnv->ReleaseStringUTFChars (jRef,ref);

return cInst;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isReference

(JNIEnv *jEnv, jobject jThs, jlong jDt)

{

_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);

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

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;

}

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 jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1before

(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 void JNICALL Java_org_pegasus_jmpi_CIMDateTime__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jDT)

{

CIMDateTime *cdt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jDT);

delete cdt;

DEBUG_ConvertCleanup (jlong, jDT);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDateTime__1getCIMString

(JNIEnv *jEnv, jobject jThs, jlong jDT)

{

CIMDateTime *cdt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jDT);

jstring jRet = 0;

if (cdt)

{

String dateString = cdt->toString ();

if (dateString.size () > 0)

{

jRet = jEnv->NewStringUTF (dateString.getCString ());

}

return jRet;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMDateTime__1getMicroseconds

(JNIEnv *jEnv, jobject jThs, jlong jDT)

{

CIMDateTime *cdt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jDT);

jlong jRet = 0;

if (cdt)

{

// Convert from 1 BCE epoch to POSIX 1970 microseconds

jRet = cdt->toMicroSeconds () - PEGASUS_UINT64_LITERAL(62167219200000000);

}

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

return DEBUG_ConvertCToJava (CIMInstance*, jlong, ci);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1filterProperties(

JNIEnv *jEnv,

jobject jThs,

jlong jInst,

jobjectArray jPl,

jboolean iq,

jboolean ic,

jboolean lo)

{

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

CIMInstance *cf = 0;

CIMName clsn = ci->getClassName ();

if (lo)

{

cf = new CIMInstance (ci->clone ());

CIMName clsn = ci->getClassName ();

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

{

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

cf->removeProperty (i);

}

return DEBUG_ConvertCToJava (CIMInstance*, jlong, cf);

}

else if (jPl)

{

CIMPropertyList pl = getList (jEnv, jPl);

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

cf = new CIMInstance (clsn);

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

{

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

if (pos != PEG_NOT_FOUND)

{

if (iq)

{

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

if (!ic)

cp.setClassOrigin (CIMName ());

cf->addProperty (cp);

}

else

{

CIMProperty cp = ci->getProperty (pos);

CIMName co;

if (ic)

co = cp.getClassOrigin ();

CIMProperty np (cp.getName (),

cp.getValue (),

cp.getArraySize (),

cp.getReferenceClassName (),

co,

cp.getPropagated ());

cf->addProperty (np);

}

cf->setPath (ci->getPath ());

}

else if (iq)

{

cf = new CIMInstance (ci->clone ());

if (ic)

return DEBUG_ConvertCToJava (CIMInstance*, jlong, cf);

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

{

CIMProperty cp = cf->getProperty (i);

cp.setClassOrigin (CIMName ());

cf->removeProperty (i);

cf->addProperty (cp);

}

else

{

cf = new CIMInstance (clsn);

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

{

CIMProperty cp = ci->getProperty (i);

CIMName co;

if (ic)

co = cp.getClassOrigin ();

CIMProperty np (cp.getName (),

cp.getValue (),

cp.getArraySize (),

cp.getReferenceClassName (),

co,

cp.getPropagated ());

cf->addProperty (np);

}

cf->setPath (ci->getPath ());

}

return DEBUG_ConvertCToJava (CIMInstance*, jlong, cf);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setName

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

{

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

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

jEnv->ReleaseStringUTFChars (jN,str);

/* NOT SUPPORTED AND NOT NEEDED*/

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperty

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

{

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

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

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

Uint32 pos;

if ( ci

&& cv

)

{

try {

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

if (pos != PEG_NOT_FOUND)

{

CIMProperty cp = ci->getProperty (pos);

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

{

cp.setValue (*cv);

}

else

{

throw CIMException(

CIM_ERR_TYPE_MISMATCH,

String ("Property type mismatch"));

}

ci->removeProperty (pos);

ci->addProperty (cp);

}

else

{

CIMProperty *cp;

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

{

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

}

else

{

if (!cv->isArray ())

{

CIMObjectPath cop;

cv->get (cop);

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

}

else

{

throwCIMException(

jEnv,

"+++ unsupported type in CIMProperty.property");

}

ci->addProperty (*cp);

}

Catch (jEnv);

}

jEnv->ReleaseStringUTFChars (jN, str);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperties

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

{

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

if (!ci)

{

return;

}

try

{

for (int i = 0, m = jEnv->CallIntMethod (jV,

JMPIjvm::jv.VectorSize);

i < m;

i++)

{

JMPIjvm::checkException (jEnv);

jobject jProp = jEnv->CallObjectMethod (jV,

JMPIjvm::jv.VectorElementAt,

i);

JMPIjvm::checkException (jEnv);

jlong jCpRef = jEnv->CallLongMethod(

jProp,

JMPIjvm::jv.CIMPropertyCInst);

CIMProperty *cpNew = DEBUG_ConvertJavaToC(

jlong,

CIMProperty*,

jCpRef);

if (cpNew)

{

Uint32 pos = ci->findProperty (cpNew->getName ());

if (pos != PEG_NOT_FOUND)

{

CIMProperty cpOld = ci->getProperty (pos);

if (cpOld.getType () == cpNew->getType ())

{

ci->removeProperty (pos);

ci->addProperty (*cpNew);

}

else

{

throw CIMException(

CIM_ERR_TYPE_MISMATCH,

String ("Property type mismatch"));

}

Catch (jEnv);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperty

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

{

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

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

jlong rv = 0;

try {

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

if (pos != PEG_NOT_FOUND)

{

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

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

}

Catch (jEnv);

jEnv->ReleaseStringUTFChars (jN, str);

return rv;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getKeyValuePairs

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

{

JMPIjvm::cacheIDs (jEnv);

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

if ( ci

&& CIMNamespaceName::legal (ci->getPath ().getNameSpace ().getString ())

)

{

CIMOMHandle ch;

OperationContext oc;

CIMClass cc;

cc = ch.getClass (oc,

ci->getPath ().getNameSpace (),

ci->getClassName (),

false, // localOnly

true, // includeQualifiers

true, // includeClassOrigin

CIMPropertyList ());// propertyList

if (!cc.hasKeys ())

{

return jVec;

}

Array<CIMName> keyNames;

cc.getKeyNames (keyNames);

for (Uint32 i = 0; i < keyNames.size (); i++)

{

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"finding key %s ",

(const char*)keyNames[i].getString().getCString()));

for (Uint32 j = 0; j < ci->getPropertyCount (); j++)

{

CIMProperty cp = ci->getProperty (j);

if (cp.getName () == keyNames[i])

{

PEG_TRACE((TRC_PROVIDERMANAGER, Tracer::LEVEL4,

"adding key (%d) %s ",i,

(const char*)keyNames[i].getString().getCString()));

CIMProperty *cpRef = new CIMProperty (cp);

jlong jCpRef = DEBUG_ConvertCToJava (CIMProperty*, jlong, cpRef);

jobject jProp = jEnv->NewObject(

JMPIjvm::jv.CIMPropertyClassRef,

JMPIjvm::jv.CIMPropertyNewJ,

jCpRef);

jEnv->CallVoidMethod (jVec,

JMPIjvm::jv.VectorAddElement,

jProp);

}

return jVec;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperties

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

{

JMPIjvm::cacheIDs (jEnv);

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

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

{

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

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

jobject prop = jEnv->NewObject(

JMPIjvm::jv.CIMPropertyClassRef,

JMPIjvm::jv.CIMPropertyNewJ,

jCp);

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

}

return jVec;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMInstance__1getClassName(

JNIEnv *jEnv,

jobject jThs,

jlong jInst)

{

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

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

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

return str;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1getQualifier

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

{

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

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

jlong rv = 0;

Uint32 pos;

if (ci)

{

try

{

CIMOMHandle ch;

OperationContext oc;

CIMClass cc;

cc = ch.getClass (oc,

ci->getPath ().getNameSpace (),

ci->getClassName (),

false, // localOnly

true, // includeQualifiers

true, // includeClassOrigin

CIMPropertyList ()); // propertyList

pos = cc.findQualifier (String (str));

if (pos != PEG_NOT_FOUND)

{

CIMQualifier *cq = 0;

cq = new CIMQualifier (cc.getQualifier (pos));

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

}

Catch (jEnv);

}

jEnv->ReleaseStringUTFChars (jN, str);

return rv;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1clone

(JNIEnv *jEnv, jobject jThs, jlong jInst)

{

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

CIMInstance *cl = new CIMInstance (ci->clone ());

return DEBUG_ConvertCToJava (CIMInstance*, jlong, cl);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jInst)

{

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

delete ci;

DEBUG_ConvertCleanup (jlong, jInst);

}

* Class: org_pegasus_jmpi_CIMInstance

* Method: _getObjectPath

* Signature: (I)I

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1getObjectPath

(JNIEnv *jEnv, jobject jThs, jlong jciCi)

{

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

CIMObjectPath *copRet = NULL;

try

{

if (ci)

{

const CIMObjectPath& cop = ci->getPath ();

copRet = new CIMObjectPath (cop);

}

Catch (jEnv);

return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, copRet);

}

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

{

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

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

try

{

if ( ci

&& cop

)

{

ci->setPath (*cop);

}

Catch (jEnv);

}

* Class: org_pegasus_jmpi_CIMInstance

* Method: _getPropertyCount

* Signature: (I)I

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getPropertyCount

(JNIEnv *jEnv, jobject jThs, jlong jciCi)

{

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

Uint32 ui32Ret = 0;

try

{

if (ci)

{

ui32Ret = ci->getPropertyCount ();

}

Catch (jEnv);

return ui32Ret;

}

* Class: org_pegasus_jmpi_CIMInstance

* Method: _getProperty

* Signature: (II)I

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMInstance__1getPropertyI

(JNIEnv *jEnv, jobject jThs, jlong jciCi, jint ji)

{

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

CIMProperty *cpRet = NULL;

try

{

if (ci)

{

CIMProperty cp;

cp = ci->getProperty (ji);

cpRet = new CIMProperty (cp);

}

Catch (jEnv);

return DEBUG_ConvertCToJava (CIMProperty*, jlong, cpRet);

}

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

// ---

// - CIMMethod

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1getType

(JNIEnv *jEnv, jobject jThs, jlong jM)

{

CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);

bool fSuccess = false;

jint jType = 0;

if (cm)

{

CIMType ct = cm->getType ();

jType = _dataType::convertCTypeToJavaType (ct, &fSuccess);

}

return jType;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMMethod__1getName

(JNIEnv *jEnv, jobject jThs, jlong jM)

{

CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);

jstring str = 0;

if (cm)

{

CIMName cn = cm->getName ();

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

}

return str;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1findParameter

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

{

CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);

jint rv = -1;

if (cm && jName)

{

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

try

{

CIMName name (cstrName);

rv = cm->findParameter (name);

}

Catch (jEnv);

jEnv->ReleaseStringUTFChars (jName, cstrName);

}

return rv;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMMethod__1getParameter

(JNIEnv *jEnv, jobject jThs, jlong jM, jint jParameter)

{

CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);

jlong rv = 0;

if (cm && jParameter >= 0)

{

try

{

CIMParameter cp = cm->getParameter (jParameter);

rv = DEBUG_ConvertCToJava(CIMParameter *, jlong, new CIMParameter(cp));

}

Catch (jEnv);

}

return rv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1getParameterCount

(JNIEnv *jEnv, jobject jThs, jlong jM)

{

CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);

jint rv = 0;

if (cm)

{

try

{

rv = cm->getParameterCount ();

}

Catch (jEnv);

}

return rv;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jM)

{

CIMMethod *cm = DEBUG_ConvertJavaToC (jlong, CIMMethod*, jM);

delete cm;

DEBUG_ConvertCleanup (jlong, jM);

}

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

// ---

// - CIMNameSpace

// ---

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

_nameSpace::_nameSpace ()

{

port_ = 0;

hostName_ = System::getHostName ();

nameSpace_ = "root/cimv2";

fHttps = false;

}

_nameSpace::_nameSpace (String hn)

{

port_ = 0;

hostName_ = hn;

nameSpace_ = "root/cimv2";

fHttps = false;

}

_nameSpace::_nameSpace (String hn, String ns)

{

port_ = 0;

hostName_ = hn;

nameSpace_ = ns;

fHttps = false;

}

int _nameSpace::port ()

{

if (port_)

return port_;

port_ = 5988;

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

if (p >= 0)

{

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

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

hostName_.remove (p);

}

return port_;

}

String _nameSpace::hostName ()

{

port ();

return hostName_;

}

String _nameSpace::nameSpace ()

{

return nameSpace_;

}

Boolean _nameSpace::isHttps ()

{

port ();

return fHttps;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1new

(JNIEnv *jEnv, jobject jThs)

{

return DEBUG_ConvertCToJava (_nameSpace*, jlong, new _nameSpace ());

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHn

(JNIEnv *jEnv, jobject jThs, jstring jHn)

{

const char *hn = jEnv->GetStringUTFChars (jHn, NULL);

jlong cInst = DEBUG_ConvertCToJava(_nameSpace*, jlong, new _nameSpace(hn));

jEnv->ReleaseStringUTFChars (jHn, hn);

return cInst;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHnNs

(JNIEnv *jEnv, jobject jThs, jstring jHn, jstring jNs)

{

const char *hn = jEnv->GetStringUTFChars (jHn, NULL);

const char *ns = jEnv->GetStringUTFChars (jNs, NULL);

jlong cInst = DEBUG_ConvertCToJava(

_nameSpace*,

jlong,

new _nameSpace(String (hn),String (ns)));

jEnv->ReleaseStringUTFChars (jHn, hn);

jEnv->ReleaseStringUTFChars (jNs, ns);

return 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 jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getHost

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

{

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

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

cNs->nameSpace_ = str;

jEnv->ReleaseStringUTFChars (jN, str);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setHost

(JNIEnv *jEnv, jobject jThs, jlong jNs, jstring jHn)

{

_nameSpace *cNs = DEBUG_ConvertJavaToC (jlong, _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__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jNs)

{

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

delete cNs;

DEBUG_ConvertCleanup (jlong, jNs);

}

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

// ---

// - CIMObject

// ---

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

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObject__1newClass

(JNIEnv *jEnv, jobject jThs, jlong jCc)

{

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

try {

CIMObject *cCo = new CIMObject (*cCc);

return DEBUG_ConvertCToJava (CIMObject*, jlong, cCo);

}

Catch (jEnv);

return 0;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObject__1newInstance

(JNIEnv *jEnv, jobject jThs, jlong jCi)

{

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

try {

CIMObject *cCo = new CIMObject (*cCi);

return DEBUG_ConvertCToJava (CIMObject*, jlong, cCo);

}

Catch (jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObject__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jInst)

{

CIMObject *co = DEBUG_ConvertJavaToC (jlong, CIMObject*, jInst);

delete co;

DEBUG_ConvertCleanup (jlong, jInst);

}

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

// ---

// - CIMObjectPath

// ---

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

CIMObjectPath* construct ()

{

CIMObjectPath *cop = new CIMObjectPath ();

_nameSpace n;

cop->setNameSpace (n.nameSpace ());

cop->setHost (n.hostName ());

return cop;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1new

(JNIEnv *jEnv, jobject jThs)

{

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

}

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

if (str1)

jEnv->ReleaseStringUTFChars (jCn, str1);

if (str2)

jEnv->ReleaseStringUTFChars (jNs, str2);

return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCi

(JNIEnv *jEnv, jobject jThs, jlong jInst)

{

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

CIMObjectPath *cop = 0;

_nameSpace n;

try

{

if (ci)

{

cop = new CIMObjectPath (ci->getPath ());

if (cop)

{

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

cop->setNameSpace (n.nameSpace ());

if (cop->getHost ().size () == 0)

cop->setHost (n.hostName ());

}

Catch (jEnv);

return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);

}

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;

try

{

cnnNamespace = pszNamespace;

fNamespaceValid = true;

}

catch (Exception e)

{

}

jEnv->ReleaseStringUTFChars (jNamespace, pszNamespace);

try

{

if (ci)

{

cop = new CIMObjectPath (ci->getPath ());

if (cop)

{

if (fNamespaceValid)

{

cop->setNameSpace (cnnNamespace);

}

else

{

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

cop->setNameSpace (n.nameSpace ());

}

if (cop->getHost ().size () == 0)

cop->setHost (n.hostName ());

}

Catch (jEnv);

return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jCop)

{

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

delete cop;

DEBUG_ConvertCleanup (jlong, jCop);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getNameSpace

(JNIEnv *jEnv, jobject jThs, jlong jCop)

{

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

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, jlong jCop, jstring jName)

{

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

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

cop->setNameSpace (CIMNamespaceName (str));

jEnv->ReleaseStringUTFChars (jName,str);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getHost

(JNIEnv *jEnv, jobject jThs, jlong jCop)

{

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

const String &hn = cop->getHost ();

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

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setHost

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

{

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

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

cop->setHost (String (str));

jEnv->ReleaseStringUTFChars (jName,str);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getObjectName

(JNIEnv *jEnv, jobject jThs, jlong jCop)

{

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

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

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

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setObjectName

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

{

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

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

cop->setClassName (String (str));

jEnv->ReleaseStringUTFChars (jName,str);

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeys

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

{

JMPIjvm::cacheIDs (jEnv);

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

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

for (Uint32 i = 0, s = akb.size (); i < s; i++)

{

const String &n = akb[i].getName ().getString ();

const String &v = akb[i].getValue ();

CIMKeyBinding::Type t = akb[i].getType ();

CIMValue *cv = 0;

switch (t)

{

case CIMKeyBinding::NUMERIC:

cv = new CIMValue ((Sint32)atol (v.getCString ()));

break;

case CIMKeyBinding::STRING:

cv = new CIMValue (v);

break;

case CIMKeyBinding::BOOLEAN:

cv = new CIMValue ((Boolean) (v.getCString ()));

break;

case CIMKeyBinding::REFERENCE:

cv = new CIMValue (CIMObjectPath (akb[i].getValue ()));

break;

default:

throwCIMException (jEnv,"+++ unsupported type: ");

}

CIMProperty *cp = 0;

if (t != CIMKeyBinding::REFERENCE)

cp = new CIMProperty (n, *cv);

else

cp = new CIMProperty(

*cv,

((CIMObjectPath) akb[i].getValue()).getClassName());

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

jobject prop = jEnv->NewObject(

JMPIjvm::jv.CIMPropertyClassRef,

JMPIjvm::jv.CIMPropertyNewJ,

jCp);

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

}

return jVec;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setKeys

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

{

JMPIjvm::cacheIDs (jEnv);

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

Array<CIMKeyBinding> akb;

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

{

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

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

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

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

}

cop->setKeyBindings (akb);

}

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

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

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

jEnv->ReleaseStringUTFChars (jId, str);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeyValue

(JNIEnv *jEnv, jobject jThs, jlong jCop, jstring jStr)

{

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

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

const char *strKeyName = jEnv->GetStringUTFChars (jStr,NULL);

jstring retStr = NULL;

for (Uint32 i = 0,s = akb.size (); i<s; i++)

{

const String &n = akb[i].getName ().getString ();

if (n == String (strKeyName))

{

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

break;

}

jEnv->ReleaseStringUTFChars (jStr,strKeyName);

return retStr;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1toString

(JNIEnv *jEnv, jobject jThs, jlong jCop)

{

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

const String &ns = cop->toString ();

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

return str;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1clone

(JNIEnv *jEnv, jobject jThs, jlong jCop)

{

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

CIMObjectPath *copl = new CIMObjectPath(

cop->getHost(),

cop->getNameSpace(),

cop->getClassName(),

cop->getKeyBindings());

return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, copl);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1set

(JNIEnv *jEnv, jobject jThs, jstring jStr)

{

const char *strCop = jEnv->GetStringUTFChars (jStr,NULL);

CIMObjectPath *cop = new CIMObjectPath ();

cop->set (String (strCop));

jEnv->ReleaseStringUTFChars (jStr,strCop);

return DEBUG_ConvertCToJava (CIMObjectPath*, jlong, cop);

}

return (jint)enmInst;

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

// ---

// - CIMOMHandle

// ---

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

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getClass

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

jboolean iq, jboolean ic, jobjectArray jPl)

{

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

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

CIMPropertyList pl;

OperationContext ctx;

if (jPl)

pl = getList (jEnv, jPl);

else

pl = CIMPropertyList ();

try {

CIMClass cls = ch->getClass (ctx,

cop->getNameSpace (),

cop->getClassName (),

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,

pl);

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

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1referenceNames

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteClass

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

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

jstring jAssocClass, jstring jRole) {

{

CIMOMHandle *ch=(CIMOMHandle*)jCh;

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

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

OperationContext ctx;

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

try {

CIMName assocClass(str);

ch->deleteClass (ctx,

jEnv->ReleaseStringUTFChars(jAssocClass,str);

cop->getNameSpace (),

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

cop->getClassName ());

String role(str);

}

jEnv->ReleaseStringUTFChars(jRole,str);

Catch(jEnv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createClass

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

{

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

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

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

OperationContext ctx;

try {

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

ch->createClass (ctx,

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

cop->getNameSpace (),

return (jint) new Array<CIMObjectPath>(enm);

*cl);

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1references

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setClass

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

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

jstring jAssocClass, jstring jRole,

{

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl) {

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

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

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

CIMPropertyList pl=getList(jEnv,jPl);

OperationContext ctx;

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

try {

CIMName assocClass(str);

ch->modifyClass (ctx,

jEnv->ReleaseStringUTFChars(jAssocClass,str);

cop->getNameSpace (),

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

*cl);

String role(str);

}

jEnv->ReleaseStringUTFChars(jRole,str);

Catch(jEnv);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClassNames

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

{

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

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

CIMNamespaceName ns = cop->getNameSpace ();

OperationContext ctx;

try {

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

Array<CIMName> enm = ch->enumerateClassNames(ctx,

cop->getNameSpace(),*cop,assocClass,role,

cop->getNameSpace(),

(Boolean)includeQualifiers,(Boolean)includeClassOrigin,pl);

cop->getClassName(),

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

(Boolean)deep);

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

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

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

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

{

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

ns,

enm[i]));

}

return (jint)enmInst;

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

}

Catch(jEnv);

return 0;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClasses

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

jboolean lo, jboolean iq, jboolean ic)

{

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

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

OperationContext ctx;

try {

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

cop->getNameSpace(),

cop->getClassName(),

(Boolean)deep,

(Boolean)lo,

(Boolean)iq,

(Boolean)ic);

return DEBUG_ConvertCToJava(

Array<CIMClass>*,

jlong,

new Array<CIMClass> (en));

}

Catch (jEnv);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent

return 0;

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

}

CIMOMHandle *ch=(CIMOMHandle*)jCh;

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getInstance(

CIMInstance *ind=(CIMInstance*)jInd;

JNIEnv *jEnv,

jobject jThs,

jlong jCh,

jlong jCop,

jboolean lo,

jboolean iq,

jboolean ic,

jobjectArray jPl)

{

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

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

OperationContext ctx;

CIMPropertyList pl;

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

if (jPl)

String name(str);

pl = getList (jEnv,jPl);

jEnv->ReleaseStringUTFChars(jName,str);

else

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

pl = CIMPropertyList ();

String ns(str);

jEnv->ReleaseStringUTFChars(jNs,str);

CIMObjectPath ref(CIMObjectPath(ind->getPath()));

try {

ref.setNameSpace(ns);

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

ind->setPath(ref);

ctx,

cop->getNameSpace(),

*cop,

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,

pl));

return DEBUG_ConvertCToJava (CIMInstance*, jlong, inst);

}

Catch (jEnv);

return 0;

}

JMPIProviderManager::indProvRecord *prec;

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance

OperationContext* context;

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

{

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

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

OperationContext ctx;

if (JMPIProviderManager::provTab.lookup(name,prec)) {

if (prec->enabled) {

context=prec->ctx;

try {

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

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

}

Catch(jEnv);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createInstance

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

{

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

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

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

OperationContext ctx;

try {

ci->setPath (*cop);

CIMObjectPath obj = ch->createInstance (ctx,

cop->getNameSpace (),

*ci);

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

}

else {

Catch (jEnv);

if (JMPIjvm::trace)

cerr<<"_deliverEvent() "<<name<<" not found"<<endl;

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1modifyInstance

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

jboolean iq, jobjectArray jPl)

{

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

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

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

CIMPropertyList pl = getList (jEnv, jPl);

OperationContext ctx;

try {

ci->setPath (*cop);

ch->modifyInstance (ctx,

cop->getNameSpace (),

*ci,

(Boolean)iq,

pl);

}

Catch (jEnv);

}

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

JNIEXPORT jlong JNICALL

// ---

Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstanceNames(

// - CIMClass

JNIEnv *jEnv,

// ---

jobject jThs,

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

jlong jCh,

jlong jCop,

jboolean deep)

{

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

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

OperationContext ctx;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1newInstance

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

CIMClass *cls=(CIMClass*)jCls;

try {

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

Array<CIMObjectPath> enm = ch->enumerateInstanceNames(

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

ctx,

cop->getNameSpace(),

cop->getClassName());

return DEBUG_ConvertCToJava(

Array<CIMObjectPath>*,

jlong,

new Array<CIMObjectPath> (enm));

}

Catch (jEnv);

return 0;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstances

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

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

{

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

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

CIMPropertyList pl;

OperationContext ctx;

if (jPl)

pl = getList (jEnv, jPl);

else

pl = CIMPropertyList ();

try {

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

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

cop->getNameSpace (),

cop->getClassName (),

(Boolean)deep,

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,

pl);

return DEBUG_ConvertCToJava(

Array<CIMInstance>*,

jlong,

new Array<CIMInstance> (en));

}

catch (Exception e) {}

Catch (jEnv);

return 0;

}

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

CIMProperty cp= cls->getProperty(i);

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1execQuery(

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

JNIEnv *jEnv,

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

jobject jThs,

jlong jCh,

jlong jCop,

jstring jQuery,

jstring jQl)

{

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

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

OperationContext ctx;

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

String query (str);

jEnv->ReleaseStringUTFChars (jQuery,str);

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

String ql (str);

jEnv->ReleaseStringUTFChars (jQl, str);

try {

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

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

cop->getNameSpace (),

ql,

query);

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

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

{

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

}

catch (Exception e) {}

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

}

Catch (jEnv);

return 0;

}

return (jint)ci;

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getProperty

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

{

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

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

OperationContext ctx;

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

CIMName prop (str);

jEnv->ReleaseStringUTFChars (jN, str);

try {

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

cop->getNameSpace (),

*cop,

prop));

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

Catch(jEnv);

return 0;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getName

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setProperty

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

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

CIMClass *cls=(CIMClass*)jCls;

{

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

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

OperationContext ctx;

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

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

CIMName pName (str);

jEnv->ReleaseStringUTFChars (jPn, str);

try {

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

ch->setProperty (ctx,

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

cop->getNameSpace (),

return str;

*cop,

pName,

*val);

}

Catch(jEnv);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associatorNames(

JNIEnv *jEnv,

jobject jThs,

jlong jCh,

jlong jCop,

jstring jAssocClass,

jstring jResultClass,

jstring jRole,

jstring jResultRole)

{

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

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

OperationContext ctx;

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

CIMName assocClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF(

"Invalid association class name"));

jEnv->Throw ((jthrowable)ev);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifier

jEnv->ReleaseStringUTFChars (jAssocClass, str);

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

CIMClass *cls=(CIMClass*)jCls;

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

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

jint rv=-1;

CIMName resultClass;

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

if (pos!=PEG_NOT_FOUND)

if ( str

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

&& *str

jEnv->ReleaseStringUTFChars(jN,str);

)

return rv;

{

if (CIMName::legal (str))

{

resultClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF(

"Invalid result class name"));

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperty

jEnv->Throw ((jthrowable)ev);

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

CIMClass *cls=(CIMClass*)jCls;

return 0;

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

}

jint rv=-1;

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

if (pos!=PEG_NOT_FOUND)

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

jEnv->ReleaseStringUTFChars(jN,str);

return rv;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1hasQualifier

jEnv->ReleaseStringUTFChars (jResultClass, str);

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

CIMClass *cls=(CIMClass*)jCls;

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

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

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

String role (str);

jEnv->ReleaseStringUTFChars(jQ,str);

return (jboolean)(pos!=PEG_NOT_FOUND);

jEnv->ReleaseStringUTFChars (jRole, str);

}

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

String resultRole (str);

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties

jEnv->ReleaseStringUTFChars (jResultRole, str);

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

CIMClass *cls=(CIMClass*)jCls;

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

try {

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

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

jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)cp);

cop->getNameSpace (),

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

*cop,

}

assocClass,

return jVec;

resultClass,

role,

resultRole);

return DEBUG_ConvertCToJava(

Array<CIMObjectPath>*,

jlong,

new Array<CIMObjectPath> (enm));

}

Catch (jEnv);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1addProperty

return 0;

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

CIMClass *cls=(CIMClass*)jCls;

CIMProperty *p=(CIMProperty*)jP;

cls->addProperty(*p);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1setProperties

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associators(

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

JNIEnv *jEnv,

CIMClass *cls=(CIMClass*)jCls;

jobject jThs,

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

jlong jCh,

cls->removeProperty(i);

jlong jCop,

jstring jAssocClass,

jstring jResultClass,

jstring jRole,

jstring jResultRole,

jboolean includeQualifiers,

jboolean includeClassOrigin,

jobjectArray jPl)

{

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

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

OperationContext ctx;

CIMPropertyList pl = getList (jEnv, jPl);

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

CIMName assocClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

for (Uint32 i=0,s=jEnv->CallIntMethod(jVec,instanceMethodIDs[28]); i<s; i++) {

else

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

{

CIMProperty *cp=(CIMProperty*)jEnv->CallIntMethod(o,instanceMethodIDs[29]);

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

cls->addProperty(*cp);

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 jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifiers

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

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

CIMClass *cls=(CIMClass*)jCls;

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

CIMName resultClass;

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

jobject qual=jEnv->NewObject(classRefs[26],instanceMethodIDs[37],(jint)cq);

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

}

return jVec;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1new

if ( str

(JNIEnv *jEnv, jobject jThs, jstring jN) {

&& *str

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

)

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

{

jEnv->ReleaseStringUTFChars(jN,str);

if (CIMName::legal (str))

return (jint)(void*)cls;

{

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

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getSuperClass

jEnv->Throw ((jthrowable)ev);

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

CIMClass *cls =(CIMClass *)jCls;

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

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

return str;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getKeys

return 0;

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

CIMClass *cls=(CIMClass*)jCls;

if (cls->hasKeys()) {

Array<CIMName> keyNames;

cls->getKeyNames(keyNames);

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

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

if (pos!=PEG_NOT_FOUND){

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

jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)cp);

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

}

return jVec;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethod

jEnv->ReleaseStringUTFChars (jResultClass, str);

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

CIMClass *cls=(CIMClass*)jCls;

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

jint rv=-1;

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

if (pos!=PEG_NOT_FOUND) {

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

}

jEnv->ReleaseStringUTFChars(jN,str);

return rv;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1equals

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

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

CIMClass *cls = (CIMClass*)jCls;

CIMClass *clsToBeCompared = (CIMClass*)jClsToBeCompared;

return cls->identical(*clsToBeCompared);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1finalize

String role (str);

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

CIMClass *cls=(CIMClass*)jCls;

delete cls;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1filterProperties

jEnv->ReleaseStringUTFChars (jRole, str);

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

CIMClass *cc=(CIMClass *)jInst;

CIMClass* cf;

CIMName clsn=cc->getClassName();

if (lo) {

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

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

CIMName clsn=cc->getClassName();

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

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

return (jint)cf;

}

else if (jPl) {

String resultRole (str);

CIMPropertyList pl=getList(jEnv,jPl);

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

jEnv->ReleaseStringUTFChars (jResultRole, str);

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

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

try {

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

Array<CIMObject> enm = ch->associators(

if (pos!=PEG_NOT_FOUND) {

ctx,

if (iq) {

cop->getNameSpace(),

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

*cop,

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

assocClass,

cf->addProperty(cp);

resultClass,

}

role,

else {

resultRole,

CIMProperty cp=cc->getProperty(pos);

(Boolean)includeQualifiers,

CIMName co;

(Boolean)includeClassOrigin,

if (ic) co=cp.getClassOrigin();

pl);

CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(),

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

cp.getReferenceClassName(),co,cp.getPropagated());

cf->addProperty(np);

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

}

{

}

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

}

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

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

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

}

Catch (jEnv);

else if (iq) {

return 0;

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

if (ic) return (jint)cf;

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

CIMProperty cp=cf->getProperty(i);

cp.setClassOrigin(CIMName());

cf->removeProperty(i);

cf->addProperty(cp);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1referenceNames

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

jstring jAssocClass, jstring jRole)

{

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

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

OperationContext ctx;

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

CIMName assocClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

jEnv->NewStringUTF(

"Invalid association class name"));

else {

jEnv->Throw ((jthrowable)ev);

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

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

return 0;

CIMProperty cp=cc->getProperty(i);

CIMName co;

if (ic) co=cp.getClassOrigin();

CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(),

cp.getReferenceClassName(),co,cp.getPropagated());

cf->addProperty(np);

}

return (jint)cf;

jEnv->ReleaseStringUTFChars (jAssocClass, str);

}

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

String role (str);

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

jEnv->ReleaseStringUTFChars (jRole, str);

// ---

// - CIMInstance

// ---

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

try {

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1new

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

(JNIEnv *jEnv, jobject jThs) {

cop->getNameSpace (),

return (jint)new CIMInstance();

*cop,

assocClass,

role);

return DEBUG_ConvertCToJava(

Array<CIMObjectPath>*,

jlong,

new Array<CIMObjectPath> (enm));

}

Catch (jEnv);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1newCn

return 0;

(JNIEnv *jEnv, jobject jThs, jstring jN) {

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

return (jint)new CIMInstance(CIMName(str));

}

//Added by Andy Viciu

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1references

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setName

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

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

jstring jAssocClass, jstring jRole,

CIMInstance *ci=(CIMInstance*)jInst;

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)

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

{

/* NOT SUPPORTED AND NOT NEEDED*/

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;

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperty

if ( str

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

&& *str

CIMInstance *ci=(CIMInstance*)jInst;

)

CIMValue *cv=(CIMValue*)jV;

{

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

if (CIMName::legal (str))

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

{

try {

assocClass = str;

if (pos!=PEG_NOT_FOUND) {

CIMProperty cp=ci->getProperty(pos);

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

cp.setValue(*cv);

else {

if (JMPIjvm::trace)

cerr<<"!!! CIMInstance.setProperty - Wrong type of CIMValue (instance name:"

<<ci->getClassName().getString()<<", property name: "<<str<<")";

if (JMPIjvm::trace)

cerr<<"!!! CIMInstance.setProperty : "<<cp.getType()<<" <> "<<cv->getType()<<endl;

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

}

ci->removeProperty(pos);

ci->addProperty(cp);

}

else {

else

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

{

ci->addProperty(*cp);

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

throw CIMException(CIM_ERR_NOT_SUPPORTED, String("Not yet supported"));

String role (str);

}

jEnv->ReleaseStringUTFChars (jRole, str);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperty

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

CIMInstance *ci=(CIMInstance*)jInst;

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

jint rv=-1;

try {

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

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

if (pos!=PEG_NOT_FOUND) {

cop->getNameSpace (),

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

*cop,

rv=(jint)cp;

assocClass,

role,

(Boolean)includeQualifiers,

(Boolean)includeClassOrigin,

pl);

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

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

{

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

}

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

}

Catch(jEnv);

jEnv->ReleaseStringUTFChars(jN,str);

return rv;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getKeyValuePairs

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

CIMInstance *ci=(CIMInstance*)jInst;

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

return 0;

if (ci->getProperty(i).findQualifier(String("key"))!=PEG_NOT_FOUND) {

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

jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)cp);

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

}

return jVec;

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod(

}

JNIEnv *jEnv,

jobject jThs,

jlong jCh,

jlong jCop,

jstring jMn,

jobject jIn,

jobject jOut)

{

JMPIjvm::cacheIDs (jEnv);

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMInstance__1getClassName

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

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

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

CIMInstance *ci=(CIMInstance*)jInst;

OperationContext ctx;

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

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

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

CIMName method (str);

return str;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getQualifier

jEnv->ReleaseStringUTFChars (jMn,str);

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

CIMInstance *ci=(CIMInstance*)jInst;

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

jint rv=-1;

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

if (pos!=PEG_NOT_FOUND) {

rv=(jint)new CIMQualifier(ci->getQualifier(pos));

}

jEnv->ReleaseStringUTFChars(jN,str);

return rv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1clone

Array<CIMParamValue> in;

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

Array<CIMParamValue> out;

CIMInstance *ci=(CIMInstance *)jInst;

CIMInstance* cl=new CIMInstance(ci->clone());

return (jint)(void*)cl;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperties

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

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

{

CIMInstance *ci=(CIMInstance*)jInst;

JMPIjvm::checkException (jEnv);

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

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

jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)cp);

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

}

return jVec;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1finalize

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

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

CIMInstance *ci=(CIMInstance*)jInst;

delete ci;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1filterProperties

JMPIjvm::checkException (jEnv);

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

CIMInstance *ci=(CIMInstance *)jInst;

CIMInstance* cf;

CIMName clsn=ci->getClassName();

if (lo) {

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

cf=new CIMInstance(ci->clone());

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

CIMName clsn=ci->getClassName();

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

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

return (jint)cf;

}

else if (jPl) {

JMPIjvm::checkException (jEnv);

CIMPropertyList pl=getList(jEnv,jPl);

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

cf=new CIMInstance(clsn);

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

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

if (pos!=PEG_NOT_FOUND) {

if (iq) {

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

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

cf->addProperty(cp);

}

else {

CIMProperty cp=ci->getProperty(pos);

CIMName co;

if (ic) co=cp.getClassOrigin();

CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(),

cp.getReferenceClassName(),co,cp.getPropagated());

cf->addProperty(np);

}

cf->setPath(ci->getPath());

}

else if (iq) {

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

cf=new CIMInstance(ci->clone());

if (ic) return (jint)cf;

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

CIMProperty cp=cf->getProperty(i);

cp.setClassOrigin(CIMName());

cf->removeProperty(i);

cf->addProperty(cp);

}

try {

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

cop->getNameSpace (),

*cop,

method,

in,

out));

else {

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

cf=new CIMInstance(clsn);

{

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

const CIMParamValue &parm = out[i];

CIMProperty cp=ci->getProperty(i);

const CIMValue v = parm.getValue ();

CIMName co;

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

if (ic) co=cp.getClassOrigin();

CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(),

v.getArraySize ());

cp.getReferenceClassName(),co,cp.getPropagated());

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

cf->addProperty(np);

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

JMPIjvm::jv.CIMPropertyNewJ,

jp);

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

}

cf->setPath(ci->getPath());

return DEBUG_ConvertCToJava (CIMValue*, jlong, val);

}

Catch (jEnv);

return (jint)cf;

return 0;

}

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

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod24

// ---

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

// - CIMObjectPath

jobjectArray jIn, jobjectArray jOut)

// ---

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

CIMObjectPath* construct() {

{

CIMObjectPath *cop=new CIMObjectPath();

JMPIjvm::cacheIDs (jEnv);

_nameSpace n;

cop->setNameSpace(n.nameSpace());

cop->setHost(n.hostName());

return cop;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1new

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

(JNIEnv *jEnv, jobject jThs) {

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);

return (jint)construct();

OperationContext ctx;

}

const char *str = jEnv->GetStringUTFChars (jMn, NULL);

CIMName method (str);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCn

jEnv->ReleaseStringUTFChars (jMn, str);

(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 (jint)(void*)cop;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCnNs

Array<CIMParamValue> in;

(JNIEnv *jEnv, jobject jThs, jstring jCn, jstring jNs) {

Array<CIMParamValue> out;

CIMObjectPath *cop=construct();

const char *str1=NULL;

const char *str2=NULL;

try {

if (jIn)

if (jCn) str1=jEnv->GetStringUTFChars(jCn,NULL);

{

if (jNs) str2=jEnv->GetStringUTFChars(jNs,NULL);

for (int i = 0, m = jEnv->GetArrayLength (jIn); i < m; i++)

if (str1) cop->setClassName(str1);

{

if (str2) cop->setNameSpace(str2);

JMPIjvm::checkException (jEnv);

}

Catch(jEnv);

if (str1) jEnv->ReleaseStringUTFChars(jCn,str1);

jobject jArg = jEnv->GetObjectArrayElement (jIn,i);

if (str2) jEnv->ReleaseStringUTFChars(jNs,str2);

return (jint)(void*)cop;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1_newCi

JMPIjvm::checkException (jEnv);

(JNIEnv *jEnv, jobject jThs, jint jInst) {

CIMInstance *ci = (CIMInstance *)jInst;

CIMObjectPath *cop=new CIMObjectPath(ci->getPath());

_nameSpace n;

if (cop->getNameSpace().isNull()) cop->setNameSpace(n.nameSpace());

if (cop->getHost()==NULL) cop->setHost(n.hostName());

return (jint)(void*)cop;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1finalize

jlong jp = jEnv->CallLongMethod (jArg,JMPIjvm::jv.CIMArgumentCInst);

(JNIEnv *jEnv, jobject jThs, jint jCop) {

CIMParamValue *p = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jp);

CIMObjectPath *cop=(CIMObjectPath*)jCop;

delete cop;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getHost

JMPIjvm::checkException (jEnv);

(JNIEnv *jEnv, jobject jThs, jint jOp) {

CIMObjectPath *cop=(CIMObjectPath*)jOp;

const String &hn=cop->getHost();

jstring str=jEnv->NewStringUTF(hn.getCString());

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setHost

in.append (*p);

(JNIEnv *jEnv, jobject jThs, jint jOp, jstring jName) {

CIMObjectPath *cop=(CIMObjectPath*)jOp;

const char *str=jEnv->GetStringUTFChars(jName,NULL);

cop->setHost(String(str));

jEnv->ReleaseStringUTFChars(jName,str);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getObjectName

(JNIEnv *jEnv, jobject jThs, jint jOp) {

CIMObjectPath *cop=(CIMObjectPath*)jOp;

const String &cn=cop->getClassName().getString();

jstring str=jEnv->NewStringUTF(cn.getCString());

return str;

}

try {

CIMValue *val = new CIMValue (ch->invokeMethod (ctx,

cop->getNameSpace (),

*cop,

method,

in,

out));

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setObjectName

if (jOut)

(JNIEnv *jEnv, jobject jThs, jint jOp, jstring jName) {

{

CIMObjectPath *cop=(CIMObjectPath*)jOp;

for (int i=0,m=out.size(),o=jEnv->GetArrayLength(jOut);i<m && i<o;i++)

const char *str=jEnv->GetStringUTFChars(jName,NULL);

{

cop->setClassName(String(str));

CIMParamValue *parm = new CIMParamValue (out[i]);

jEnv->ReleaseStringUTFChars(jName,str);

jlong jParm = DEBUG_ConvertCToJava (CIMParamValue*, jlong, parm);

jEnv->SetObjectArrayElement(

jOut,

jEnv->NewObject(

JMPIjvm::jv.CIMArgumentClassRef,

JMPIjvm::jv.CIMArgumentNewJ,jParm));

}

return DEBUG_ConvertCToJava (CIMValue*, jlong, val);

}

Catch (jEnv);

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getNameSpace

return 0;

(JNIEnv *jEnv, jobject jThs, jint jOp) {

CIMObjectPath *cop=(CIMObjectPath*)jOp;

const String &ns=cop->getNameSpace().getString();

jstring str=jEnv->NewStringUTF(ns.getCString());

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setNameSpace

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent(

(JNIEnv *jEnv, jobject jThs, jint jOp, jstring jName) {

JNIEnv *jEnv,

CIMObjectPath *cop=(CIMObjectPath*)jOp;

jobject jThs,

jlong jCh,

jstring jName,

jstring jNs,

jlong jInd)

{

CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);

CIMInstance *ind = DEBUG_ConvertJavaToC (jlong, CIMInstance*, jInd);

const char *str=jEnv->GetStringUTFChars(jName,NULL);

cop->setNameSpace(CIMNamespaceName(str));

String name (str);

jEnv->ReleaseStringUTFChars(jName,str);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1addKey

str = jEnv->GetStringUTFChars (jNs, NULL);

(JNIEnv *jEnv, jobject jThs, jint jOp, jstring jId, jint jVal) {

CIMObjectPath *cop=(CIMObjectPath*)jOp;

const char *str=jEnv->GetStringUTFChars(jId,NULL);

CIMValue *cv=(CIMValue*)jVal;

Array<CIMKeyBinding> keyBindings=cop->getKeyBindings();

keyBindings.append(CIMKeyBinding(str,*cv));

cop->setKeyBindings(Array<CIMKeyBinding>(keyBindings));

jEnv->ReleaseStringUTFChars(jId,str);

return;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeys

String ns (str);

(JNIEnv *jEnv, jobject jThs, jint jOp, jobject jVec) {

CIMObjectPath *cop=(CIMObjectPath*)jOp;

const Array<CIMKeyBinding> &akb=cop->getKeyBindings();

for (Uint32 i=0,s=akb.size(); i<s; i++) {

jEnv->ReleaseStringUTFChars (jNs, str);

const String &n=akb[i].getName().getString();

const String &v=akb[i].getValue();

CIMKeyBinding::Type t=akb[i].getType();

CIMValue *cv;

switch (t) {

case CIMKeyBinding::NUMERIC:

cv=new CIMValue((Sint32)atol(v.getCString()));

break;

case CIMKeyBinding::STRING:

cv=new CIMValue(v);

break;

case CIMKeyBinding::BOOLEAN:

cv=new CIMValue((Boolean)(v.getCString()));

break;

case CIMKeyBinding::REFERENCE:

cv = new CIMValue(CIMObjectPath(akb[i].getValue()));

break;

default:

throwCIMException(jEnv,"+++ unsupported type: ");

}

CIMProperty *cp;

CIMObjectPath ref (ind->getPath ());

if(t!=CIMKeyBinding::REFERENCE)

cp=new CIMProperty(n,*cv);

else cp=new CIMProperty(n,*cv, 0, ((CIMObjectPath) akb[i].getValue()).getClassName());

jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)cp);

ref.setNameSpace (ns);

jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],prop);

}

return jVec;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeyValue

PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,

(JNIEnv *jEnv, jobject jThs, jint jOp, jstring jStr) {

"Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent(): ref = %s",

CIMObjectPath *cop=(CIMObjectPath*)jOp;

(const char*)ref.toString().getCString()));

const Array<CIMKeyBinding> &akb=cop->getKeyBindings();

PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,

const char *strKeyName=jEnv->GetStringUTFChars(jStr,NULL);

"Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent(): ind = %s",

jstring retStr=NULL;

(const char*)ind->getPath().toString().getCString()));

for (Uint32 i=0,s=akb.size(); i<s; i++) {

const String &n=akb[i].getName().getString();

ind->setPath (ref);

if (n==String(strKeyName)) {

retStr=jEnv->NewStringUTF(akb[i].getValue().getCString());

PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,

break;

"Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent(): ind = %s",

(const char*)ind->getPath().toString().getCString()));

JMPIProviderManager::indProvRecord *prec = NULL;

String sPathString = ind->getPath ().toString ();

OperationContext *context = NULL;

bool fResult = false;

{

AutoMutex lock (JMPIProviderManager::mutexProvTab);

fResult = JMPIProviderManager::provTab.lookup (name, prec);

PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,

"Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent(): "

"fResult = %d, name = %s",

fResult,(const char*)name.getCString()));

}

if (fResult)

{

if (prec->enabled)

{

try

{

prec->handler->deliver (*prec->ctx, *ind);

}

jEnv->ReleaseStringUTFChars(jStr,strKeyName);

Catch (jEnv);

return retStr;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1set

(JNIEnv *jEnv, jobject jThs, jstring jStr) {

const char *strCop=jEnv->GetStringUTFChars(jStr,NULL);

CIMObjectPath *cop=new CIMObjectPath();

cop->set(String(strCop));

jEnv->ReleaseStringUTFChars(jStr,strCop);

return (jint)cop;

}

else

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setKeys

{

(JNIEnv *jEnv, jobject jThs, jint jOp, jobject jVec) {

PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL2,

CIMObjectPath *cop=(CIMObjectPath*)jOp;

"Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent(): "

Array<CIMKeyBinding> akb;

"provider name \"%s\" not found",

for (Uint32 i=0,s=jEnv->CallIntMethod(jVec,instanceMethodIDs[28]); i<s; i++) {

(const char*)name.getCString()));

jobject o=jEnv->CallObjectMethod(jVec,instanceMethodIDs[16],(i));

CIMProperty *cp=(CIMProperty*)jEnv->CallIntMethod(o,instanceMethodIDs[29]);

akb.append(CIMKeyBinding(cp->getName(),cp->getValue()));

}

cop->setKeyBindings(akb);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1clone

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1finalize

(JNIEnv *jEnv, jobject jThs, jint jOp) {

(JNIEnv *jEnv, jobject jThs, jlong jCh)

CIMObjectPath *cop=(CIMObjectPath*)jOp;

{

CIMObjectPath *copl=new CIMObjectPath(cop->getHost(), cop->getNameSpace(), cop->getClassName(), cop->getKeyBindings());

CIMOMHandle *ch = DEBUG_ConvertJavaToC (jlong, CIMOMHandle*, jCh);

return (jint)(void*)copl;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1toString

delete ch;

(JNIEnv *jEnv, jobject jThs, jint jOp) {

CIMObjectPath *cop=(CIMObjectPath*)jOp;

DEBUG_ConvertCleanup (jlong, jCh);

const String &ns=cop->toString();

jstring str=jEnv->NewStringUTF(ns.getCString());

return str;

}

// -------------------------------------

// ---

// - CIMDataType

// - CIMParameter

// ---

// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1new

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMParameter__1getName

(JNIEnv *jEnv, jobject jThs, jint type) {

(JNIEnv *jEnv, jobject jThs, jlong jCp)

return (jint)(void*) new _dataType(type);

{

CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);

jstring rv = 0;

if (cp)

{

try

{

CIMName name = cp->getName ();

rv = jEnv->NewStringUTF (name.getString ().getCString ());

}

Catch (jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newAr

return rv;

(JNIEnv *jEnv, jobject jThs, jint type, jint size) {

return (jint)(void*) new _dataType(type,size);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newRef

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMParameter__1setName

(JNIEnv *jEnv, jobject jThs, jint type, jstring jRef) {

(JNIEnv *jEnv, jobject jThs, jlong jCp, jstring jName)

const char *ref=jEnv->GetStringUTFChars(jRef,NULL);

{

jint cInst=(jint)(void*)new _dataType(type,String(ref));

CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);

jEnv->ReleaseStringUTFChars(jRef,ref);

return cInst;

if (cp && jName)

{

try

{

const char *cstrName = jEnv->GetStringUTFChars (jName, NULL);

CIMName name (cstrName);

cp->setName (name);

jEnv->ReleaseStringUTFChars (jName, cstrName);

}

Catch (jEnv);

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isArray

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMParameter__1isArray

(JNIEnv *jEnv, jobject jThs, jint jDt) {

(JNIEnv *jEnv, jobject jThs, jlong jCp)

_dataType *dt=(_dataType*)jDt;

{

return dt->_array==true;

CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);

jboolean rv = 0;

if (cp)

{

try

{

rv = cp->isArray ();

}

Catch (jEnv);

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isreference

return rv;

(JNIEnv *jEnv, jobject jThs, jint jDt) {

_dataType *dt=(_dataType*)jDt;

return dt->_reference==true;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isReference

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMParameter__1getArraySize

(JNIEnv *jEnv, jobject jThs, jint jDt) {

(JNIEnv *jEnv, jobject jThs, jlong jCp)

_dataType *dt=(_dataType*)jDt;

{

return dt->_reference==true;

CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);

jint rv = 0;

if (cp)

{

try

{

rv = cp->getArraySize ();

}

Catch (jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getType

return rv;

(JNIEnv *jEnv, jobject jThs, jint jDt) {

_dataType *dt=(_dataType*)jDt;

return dt->_type;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getSize

JNIEXPORT jstring JNICALL

(JNIEnv *jEnv, jobject jThs, jint jDt) {

Java_org_pegasus_jmpi_CIMParameter__1getReferenceClassName(

_dataType *dt=(_dataType*)jDt;

JNIEnv *jEnv,

return dt->_size;

jobject jThs,

jlong jCp)

{

CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);

jstring rv = 0;

if (cp)

{

try

{

CIMName name = cp->getReferenceClassName ();

rv = jEnv->NewStringUTF (name.getString ().getCString ());

}

Catch (jEnv);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1getRefClassName

return rv;

(JNIEnv *jEnv, jobject jThs, jint jDt) {

_dataType *dt=(_dataType*)jDt;

jstring str=jEnv->NewStringUTF(dt->_refClass.getCString());

return str;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1toString

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMParameter__1getType

(JNIEnv *jEnv, jobject jThs, jint jDt) {

(JNIEnv *jEnv, jobject jThs, jlong jCp)

_dataType *dt=(_dataType*)jDt;

{

jstring str=NULL;

CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);

if (dt->_type & 0x10) {

jlong rv = 0;

char tmp[32];

strcpy(tmp,jTypeToChars[dt->_type-0x10]);

if (cp)

strcat(tmp,"[]");

{

str=jEnv->NewStringUTF(tmp);

try

{

CIMType ct = cp->getType ();

bool fSuccess = false;

String ref = cp->getReferenceClassName ().getString ();

int iJType = 0;

_dataType *type = 0;

iJType = _dataType::convertCTypeToJavaType (ct, &fSuccess);

if (fSuccess)

{

type = new _dataType (iJType,

cp->getArraySize (),

false,

cp->isArray (),

ref,

true);

rv = DEBUG_ConvertCToJava (_dataType*, jlong, type);

}

else if (dt->_type & 0x20) {

String tmp=dt->_refClass+" REF";

str=jEnv->NewStringUTF(tmp.getCString());

}

else {

Catch (jEnv);

str=jEnv->NewStringUTF(jTypeToChars[dt->_type]);

}

return str;

return rv;

}

CIMType toPtype(int jType) {

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMParameter__1finalize

if (jType>13) return (CIMType)14;

(JNIEnv *jEnv, jobject jThs, jlong jCp)

return (CIMType)(jTypeToPType[jType]);

{

CIMParameter *cp = DEBUG_ConvertJavaToC (jlong, CIMParameter*, jCp);

delete cp;

DEBUG_ConvertCleanup (jlong, jCp);

}

// -------------------------------------

// ---

// - CIMArgument

// - CIMProperty

// ---

// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1getValue

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1getValue

(JNIEnv *jEnv, jobject jThs, jint jP) {

(JNIEnv *jEnv, jobject jThs, jlong jP)

CIMParamValue *cp=(CIMParamValue*)jP;

{

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

CIMValue *cv=new CIMValue(cp->getValue());

return (jint)cv;

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1new

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getName

(JNIEnv *jEnv, jobject jThs) {

(JNIEnv *jEnv, jobject jThs, jlong jP)

CIMParamValue *p=new CIMParamValue(String::EMPTY,CIMValue());

{

return (jint)p;

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

const String &n = cp->getName ().getString ();

jstring str = jEnv->NewStringUTF (n.getCString ());

return str;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1newS

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setName

(JNIEnv *jEnv, jobject jThs, jstring jN) {

(JNIEnv *jEnv, jobject jThs, jlong jP, jstring jN)

{

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

const char *str=jEnv->GetStringUTFChars(jN,NULL);

CIMParamValue *p=new CIMParamValue(str,CIMValue());

cp->setName (CIMName (str));

jEnv->ReleaseStringUTFChars(jN,str);

return (jint)p;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1newSV

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1property

(JNIEnv *jEnv, jobject jThs, jstring jN, jint jV) {

(JNIEnv *jEnv, jobject jThs, jstring jN, jlong jV)

{

CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);

const char *str=jEnv->GetStringUTFChars(jN,NULL);

CIMValue *cv=(CIMValue*)jV;

CIMProperty *cp = 0;

CIMParamValue *p=new CIMParamValue(str,cv);

jlong jCp = 0;

try {

if (cv->getType ()!= CIMTYPE_REFERENCE)

{

cp = new CIMProperty (String (str),*cv);

}

else

{

if (!cv->isArray ())

{

CIMObjectPath cop;

cv->get (cop);

cp = new CIMProperty (String (str),*cv,0, cop.getClassName ());

}

else

{

throwCIMException(

jEnv,

"+++ unsupported type in CIMProperty.property");

}

jCp = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp);

}

Catch (jEnv);

jEnv->ReleaseStringUTFChars(jN,str);

return (jint)p;

return jCp;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setValue

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1new

(JNIEnv *jEnv, jobject jThs, jint jP,jint jV) {

(JNIEnv *jEnv, jobject jThs, jstring jN, jlong jV)

CIMParamValue *cp=(CIMParamValue*)jP;

{

CIMValue *cv=(CIMValue*)jV;

CIMProperty *p = new CIMProperty (CIMName (),CIMValue ());

cp->setValue(*cv);

return DEBUG_ConvertCToJava (CIMProperty*, jlong, p);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMArgument__1getName

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isReference

(JNIEnv *jEnv, jobject jThs, jint jP) {

(JNIEnv *jEnv, jobject jThs, jlong jP)

CIMParamValue *cp=(CIMParamValue*)jP;

{

const String &n=cp->getParameterName();

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

return (jboolean) (cp->getType () == CIMTYPE_REFERENCE);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getRefClassName

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

const String &n = cp->getReferenceClassName ().getString ();

jstring str=jEnv->NewStringUTF(n.getCString());

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setName

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1getType

(JNIEnv *jEnv, jobject jThs, jint jP, jstring jN) {

(JNIEnv *jEnv, jobject jThs, jlong jP)

CIMParamValue *cp=(CIMParamValue*)jP;

{

const char *str=jEnv->GetStringUTFChars(jN,NULL);

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

String n(str);

String ref = cp->getReferenceClassName ().getString ();

cp->setParameterName(n);

bool fSuccess = false;

jEnv->ReleaseStringUTFChars(jN,str);

int iJType = 0;

}

_dataType *type = 0;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1getType

iJType = _dataType::convertCTypeToJavaType (cp->getType (), &fSuccess);

(JNIEnv *jEnv, jobject jThs, jint jP) {

CIMParamValue *cp=(CIMParamValue*)jP;

if (fSuccess)

const CIMValue cv=cp->getValue();

{

String ref;

type = new _dataType (iJType,

_dataType *type=new _dataType(pTypeToJType[cv.getType()],

cp->getArraySize (),

cv.getArraySize(),

ref.size () ? true : false,

false,

cv.isArray(),

cp->isArray (),

ref,

true);

return (jint)type;

}

return DEBUG_ConvertCToJava (_dataType*, jlong, type);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1setType

(JNIEnv *jEnv, jobject jThs, jlong jP, jlong jDt)

{

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

_dataType *dt = DEBUG_ConvertJavaToC (jlong, _dataType*, jDt);

CIMValue val;

bool fSuccess = false;

CIMType cType = CIMTYPE_BOOLEAN;

cType = _dataType::convertJavaTypeToCType (dt->_type, &fSuccess);

// -------------------------------------

if (fSuccess)

// ---

{

// - CIMProperty

val.setNullValue (cType, dt->_array);

// ---

// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getValue

CIMProperty *np = new CIMProperty (cp->getName (), val);

(JNIEnv *jEnv, jobject jThs, jint jP) {

CIMProperty *cp=(CIMProperty*)jP;

CIMValue *cv=new CIMValue(cp->getValue());

return (jint)cv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1new

delete cp;

(JNIEnv *jEnv, jobject jThs, jstring jN, jint jV) {

CIMProperty *p=new CIMProperty(CIMName(),CIMValue());

return (jint)p;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1property

DEBUG_ConvertCleanup (jlong, jP);

(JNIEnv *jEnv, jobject jThs, jstring jN, jint jV) {

try {

CIMValue *cv=(CIMValue*)jV;

const char *str=jEnv->GetStringUTFChars(jN,NULL);

CIMProperty *cp;

if (cv->getType()!=CIMTYPE_REFERENCE)

return DEBUG_ConvertCToJava (CIMProperty*, jlong, np);

cp=new CIMProperty(String(str),*cv);

else {

if (!cv->isArray()) {

CIMObjectPath cop;

cv->get(cop);

cp=new CIMProperty(String(str),*cv,0, cop.getClassName());

}

else {

else

throwCIMException(jEnv,"+++ unsupported type in CIMProperty.property");

{

}

return DEBUG_ConvertCToJava (CIMProperty*, jlong, cp);

}

jEnv->ReleaseStringUTFChars(jN,str);

return (jint)cp;

}

Catch(jEnv);

return -1;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setValue

(JNIEnv *jEnv, jobject jThs, jint jP,jint jV) {

(JNIEnv *jEnv, jobject jThs, jlong jP,jlong jV)

CIMProperty *cp=(CIMProperty*)jP;

{

CIMValue *cv=(CIMValue*)jV;

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);

cp->setValue(*cv);

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isArray

(JNIEnv *jEnv, jobject jThs, jint jP) {

(JNIEnv *jEnv, jobject jThs, jlong jP)

CIMProperty *cp=(CIMProperty*)jP;

{

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

return (jboolean)cp->isArray();

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getIdentifier

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

const String &n = cp->getName ().getString ();

jstring str = jEnv->NewStringUTF (n.getCString ());

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addValue

(JNIEnv *jEnv, jobject jThs, jint jP, jint jV) {

(JNIEnv *jEnv, jobject jThs, jlong jP, jlong jV)

CIMProperty *cp=(CIMProperty*)jP;

{

CIMValue *cvin=(CIMValue*)jV;

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

CIMValue *cvin = DEBUG_ConvertJavaToC (jlong, 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();

switch (type) {

case CIMTYPE_BOOLEAN: {

switch (type)

{

case CIMTYPE_BOOLEAN:

{

Boolean bo;

cvin->get(bo);

Array<Boolean> boarr;

cv.get(boarr);

boarr.append(bo);

}

cv.set (boarr);

break;

case CIMTYPE_UINT8: {

}

case CIMTYPE_UINT8:

{

Uint8 u8;

cvin->get(u8);

Array<Uint8> u8arr;

cv.get(u8arr);

u8arr.append(u8);

}

cv.set (u8arr);

break;

case CIMTYPE_SINT8: {

}

case CIMTYPE_SINT8:

{

Sint8 s8;

cvin->get(s8);

Array<Sint8> s8arr;

cv.get(s8arr);

s8arr.append(s8);

}

cv.set (s8arr);

break;

case CIMTYPE_UINT16: {

}

case CIMTYPE_UINT16:

{

Uint16 u16;

cvin->get(u16);

Array<Uint16> u16arr;

cv.get(u16arr);

u16arr.append(u16);

}

cv.set (u16arr);

break;

case CIMTYPE_SINT16: {

}

case CIMTYPE_SINT16:

{

Sint16 s16;

cvin->get(s16);

Array<Sint16> s16arr;

cv.get(s16arr);

s16arr.append(s16);

}

cv.set (s16arr);

break;

case CIMTYPE_UINT32: {

}

case CIMTYPE_UINT32:

{

Uint32 u32;

cvin->get(u32);

Array<Uint32> u32arr;

cv.get(u32arr);

u32arr.append(u32);

}

cv.set (u32arr);

break;

case CIMTYPE_SINT32: {

}

case CIMTYPE_SINT32:

{

Sint32 s32;

cvin->get(s32);

Array<Sint32> s32arr;

cv.get(s32arr);

s32arr.append(s32);

}

cv.set (s32arr);

break;

case CIMTYPE_UINT64: {

}

case CIMTYPE_UINT64:

{

Uint64 u64;

cvin->get(u64);

Array<Uint64> u64arr;

cv.get(u64arr);

u64arr.append(u64);

}

cv.set (u64arr);

break;

case CIMTYPE_SINT64: {

}

case CIMTYPE_SINT64:

{

Sint64 s64;

cvin->get(s64);

Array<Sint64> s64arr;

cv.get(s64arr);

s64arr.append(s64);

}

cv.set (s64arr);

break;

case CIMTYPE_REAL32: {

}

case CIMTYPE_REAL32:

{

Real32 f;

cvin->get(f);

Array<Real32> farr;

cv.get(farr);

farr.append(f);

}

cv.set (farr);

break;

case CIMTYPE_REAL64: {

}

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;

cvin->get (c16);

Array<Char16> c16arr;

cv.get (c16arr);

c16arr.append (c16);

cv.set (c16arr);

break;

case CIMTYPE_STRING: {

}

case CIMTYPE_STRING:

{

String str;

cvin->get(str);

Array<String> strarr;

cv.get(strarr);

strarr.append(str);

cv.set (strarr);

break;

}

case CIMTYPE_DATETIME:

{

CIMDateTime dt;

cvin->get (dt);

Array<CIMDateTime> dtarr;

cv.get (dtarr);

dtarr.append (dt);

cv.set (dtarr);

break;

case CIMTYPE_REFERENCE: {

}

case CIMTYPE_REFERENCE:

{

CIMObjectPath ref;

cvin->get(ref);

Array<CIMObjectPath> refarr;

cv.get(refarr);

refarr.append(ref);

}

cv.set (refarr);

break;

case CIMTYPE_OBJECT: {

}

case CIMTYPE_OBJECT:

{

CIMObject obj;

cvin->get(obj);

Array<CIMObject> objarr;

cv.get(objarr);

objarr.append(obj);

}

cv.set (objarr);

break;

}

default:

{

throwCIMException(jEnv,"+++ unsupported type ");

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addQualifier

cp->setValue (cv);

(JNIEnv *jEnv, jobject jThs, jint jP, jint jQ) {

CIMProperty *cp=(CIMProperty*)jP;

CIMQualifier *cq=(CIMQualifier*)jQ;

cp->addQualifier(*cq);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getName

(JNIEnv *jEnv, jobject jThs, jint jP) {

CIMProperty *cp=(CIMProperty*)jP;

const String &n=cp->getName().getString();

jstring str=jEnv->NewStringUTF(n.getCString());

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setName

(JNIEnv *jEnv, jobject jThs, jint jP, jstring jN) {

CIMProperty *cp=(CIMProperty*)jP;

const char *str=jEnv->GetStringUTFChars(jN,NULL);

cp->setName(CIMName(str));

jEnv->ReleaseStringUTFChars(jN,str);

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isReference

(JNIEnv *jEnv, jobject jThs, jint jP) {

CIMProperty *cp=(CIMProperty*)jP;

return (jboolean)(cp->getType()==CIMTYPE_REFERENCE);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getRefClassName

(JNIEnv *jEnv, jobject jThs, jint jP) {

CIMProperty *cp=(CIMProperty*)jP;

const String &n=cp->getReferenceClassName().getString();

jstring str=jEnv->NewStringUTF(n.getCString());

return str;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getType

(JNIEnv *jEnv, jobject jThs, jint jP) {

CIMProperty *cp=(CIMProperty*)jP;

String ref=cp->getReferenceClassName().getString();

_dataType *type=new _dataType(pTypeToJType[cp->getType()],

cp->getArraySize(),

ref.size() ? true : false,

false,

cp->isArray(),

ref,

true);

return (jint)type;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1setType

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addQualifier

(JNIEnv *jEnv, jobject jThs, jint jP, jint jDt) {

(JNIEnv *jEnv, jobject jThs, jlong jP, jlong jQ)

CIMProperty *cp=(CIMProperty*)jP;

{

_dataType *dt=(_dataType*)jDt;

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

CIMValue val;

CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ);

val.setNullValue(toPtype(dt->_type),dt->_array);

CIMProperty *np=new CIMProperty(cp->getName(),val);

delete cp;

return (jint)np;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMProperty__1getIdentifier

cp->addQualifier (*cq);

(JNIEnv *jEnv, jobject jThs, jint jP) {

CIMProperty *cp=(CIMProperty*)jP;

const String &n=cp->getName().getString();

jstring str=jEnv->NewStringUTF(n.getCString());

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1finalize

(JNIEnv *jEnv, jobject jThs, jint jP) {

(JNIEnv *jEnv, jobject jThs, jlong jP)

CIMProperty *cp=(CIMProperty*)jP;

{

delete cp;

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

}

// -------------------------------------

// ---

// - CIMQualifierType

// ---

// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1new

delete cp;

(JNIEnv *jEnv, jobject jThs) {

CIMQualifierDecl *qual = new CIMQualifierDecl();

return (jint)(void*)qual;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1finalize

DEBUG_ConvertCleanup (jlong, jP);

(JNIEnv *jEnv, jobject jThs, jint jQ) {

CIMQualifierDecl *qt=(CIMQualifierDecl*)jQ;

delete qt;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1getName

(JNIEnv *jEnv, jobject jThs, jint jQ) {

* Class: org_pegasus_jmpi_CIMProperty

CIMQualifierDecl *qt=(CIMQualifierDecl*)jQ;

* Method: _findQualifier

const String &n=qt->getName().getString();

* Signature: (Ljava/lang/String;)I

jstring str=jEnv->NewStringUTF(n.getCString());

return str;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1findQualifier

}

(JNIEnv *jEnv, jobject jThs, jlong jP, jstring jQualifier)

{

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

const char *str = jEnv->GetStringUTFChars (jQualifier, NULL);

Uint32 index = PEG_NOT_FOUND;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setName

try

(JNIEnv *jEnv, jobject jThs, jint jQ, jstring jN) {

{

CIMQualifierDecl *nqt,*qt=(CIMQualifierDecl*)jQ;

index = cp->findQualifier (CIMName (str));

nqt=qt;

const char *str=jEnv->GetStringUTFChars(jN,NULL);

jEnv->ReleaseStringUTFChars (jQualifier, str);

if (qt->isUninitialized())

nqt=new CIMQualifierDecl(CIMName(str),CIMValue(),CIMScope());

else qt->setName(CIMName(str));

jEnv->ReleaseStringUTFChars(jN,str);

return (jint)nqt;

}

Catch (jEnv);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setValue

return index;

(JNIEnv *jEnv, jobject jThs, jint jQ,jint jV) {

CIMQualifierDecl *qt=(CIMQualifierDecl*)jQ;

CIMValue *cv=(CIMValue*)jV;

qt->setValue(*cv);

}

* Class: org_pegasus_jmpi_CIMProperty

* Method: _getQualifier

* Signature: (I)I

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMProperty__1getQualifier

(JNIEnv *jEnv, jobject jThs, jlong jP, jint jIndex)

{

CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

CIMQualifier *cq = NULL;

CIMQualifier qualifier;

try

{

qualifier = cp->getQualifier ((Uint32)jIndex);

cq = new CIMQualifier (qualifier);

}

Catch (jEnv);

return DEBUG_ConvertCToJava (CIMQualifier *, jlong, cq);

}

// -------------------------------------

Line 2200

Line 6264

// ---

// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifier__1new

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMQualifier__1new

(JNIEnv *jEnv, jobject jThs, jstring jN) {

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

const char *str=jEnv->GetStringUTFChars(jN,NULL);

CIMQualifier *qual = new CIMQualifier(CIMName(str),CIMValue());

jEnv->ReleaseStringUTFChars(jN,str);

return (jint)(void*)qual;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1finalize

return DEBUG_ConvertCToJava (CIMQualifier*, jlong, qual);

(JNIEnv *jEnv, jobject jThs, jint jQ) {

CIMQualifier *cq=(CIMQualifier*)jQ;

delete cq;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getName

(JNIEnv *jEnv, jobject jThs, jint jQ) {

(JNIEnv *jEnv, jobject jThs, jlong jQ)

CIMQualifier *cq=(CIMQualifier*)jQ;

{

CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ);

const String &n=cq->getName().getString();

jstring str=jEnv->NewStringUTF(n.getCString());

return str;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getValue

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getValue

(JNIEnv *jEnv, jobject jThs, jint jQ) {

(JNIEnv *jEnv, jobject jThs, jlong jQ)

CIMQualifier *cq=(CIMQualifier*)jQ;

{

CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ);

CIMValue *cv=new CIMValue(cq->getValue());

return (jint)cv;

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1setValue

(JNIEnv *jEnv, jobject jThs, jint jQ,jint jV) {

(JNIEnv *jEnv, jobject jThs, jlong jQ,jlong jV)

CIMQualifier *cq=(CIMQualifier*)jQ;

{

CIMValue *cv=(CIMValue*)jV;

CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ);

CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);

cq->setValue(*cv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jQ)

{

CIMQualifier *cq = DEBUG_ConvertJavaToC (jlong, CIMQualifier*, jQ);

delete cq;

DEBUG_ConvertCleanup (jlong, jQ);

}

// -------------------------------------

// ---

// - CIMDateTime

// - CIMQualifierType

// ---

// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetime

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1new

(JNIEnv *jEnv, jobject jThs, jstring jN) {

(JNIEnv *jEnv, jobject jThs)

const char *str=jEnv->GetStringUTFChars(jN,NULL);

{

CIMDateTime *dt;

CIMQualifierDecl *qual = new CIMQualifierDecl ();

if (strlen(str)==0)

dt=new CIMDateTime();

else

dt=new CIMDateTime(String(str));

jEnv->ReleaseStringUTFChars(jN,str);

return (jint)dt;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetimeempty

return DEBUG_ConvertCToJava (CIMQualifierDecl*, jlong, qual);

(JNIEnv *jEnv, jobject jThs) {

CIMDateTime *dt=new CIMDateTime(CIMDateTime::getCurrentDateTime ());

return (jint)dt;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1after

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1getName

(JNIEnv *jEnv, jobject jThs, jint jC, jint jD) {

(JNIEnv *jEnv, jobject jThs, jlong jQ)

CIMDateTime *ct = (CIMDateTime *) jC;

{

CIMDateTime *dt = (CIMDateTime *) jD;

CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jlong, CIMQualifierDecl*, jQ);

return (jboolean)(ct->getDifference(*ct, *dt)>0);

const String &n = qt->getName ().getString ();

jstring str = jEnv->NewStringUTF (n.getCString ());

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDateTime__1finalize

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setName

(JNIEnv *jEnv, jobject jThs, jint jDT) {

(JNIEnv *jEnv, jobject jThs, jlong jQ, jstring jN)

CIMDateTime *cdt = (CIMDateTime *) jDT;

{

delete cdt;

CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jlong, CIMQualifierDecl*, jQ);

const char *str = jEnv->GetStringUTFChars (jN, NULL);

jlong jret = 0;

if (qt->isUninitialized ())

{

CIMQualifierDecl *nqt = new CIMQualifierDecl(

CIMName(str),

CIMValue(),

CIMScope());

jret = DEBUG_ConvertCToJava (CIMQualifierDecl*, jlong, nqt);

}

else

{

qt->setName (CIMName (str));

CIMQualifierDecl *nqt = new CIMQualifierDecl (*qt);

// -------------------------------------

jret = DEBUG_ConvertCToJava (CIMQualifierDecl*, jlong, nqt);

// ---

}

// - CIMMethod

// ---

// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1getType

jEnv->ReleaseStringUTFChars (jN, str);

(JNIEnv *jEnv, jobject jThs, jint jM) {

CIMMethod *cm=(CIMMethod*)jM;

return jret;

return (jint)cm->getType();

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setValue

(JNIEnv *jEnv, jobject jThs, jint jM) {

(JNIEnv *jEnv, jobject jThs, jlong jQ,jlong jV)

CIMMethod *cm=(CIMMethod*)jM;

{

delete cm;

CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jlong, CIMQualifierDecl*, jQ);

CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);

qt->setValue (*cv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jQ)

{

CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jlong, CIMQualifierDecl*, jQ);

delete qt;

DEBUG_ConvertCleanup (jlong, jQ);

}

// -------------------------------------

// ---

Line 2300

Line 6393

// ---

// -------------------------------------

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1byte

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byte

(JNIEnv *jEnv, jobject jThs, jbyte jb, jboolean notSigned)

(JNIEnv *jEnv, jobject jThs, jbyte jb, jboolean notSigned) {

{

CIMValue *cv=NULL;

if (notSigned) cv=new CIMValue((Uint8)jb);

else cv=new CIMValue((Sint8)jb);

if (notSigned)

return (jint)cv;

cv = new CIMValue ((Uint8)jb);

else

cv = new CIMValue ((Sint8)jb);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1short

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1short

(JNIEnv *jEnv, jobject jThs, jshort js, jboolean notSigned) {

(JNIEnv *jEnv, jobject jThs, jshort js, jboolean notSigned)

{

CIMValue *cv=NULL;

if (notSigned) cv=new CIMValue((Uint16)js);

else cv=new CIMValue((Sint16)js);

if (notSigned)

return (jint)cv;

cv = new CIMValue ((Uint16)js);

else

cv = new CIMValue( (Sint16)js);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue_makeInt

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1makeInt

(JNIEnv *jEnv, jobject jThs, jlong ji, jboolean notSigned) {

(JNIEnv *jEnv, jobject jThs, jlong ji, jboolean notSigned)

{

CIMValue *cv=NULL;

if (notSigned) cv=new CIMValue((Uint32)ji);

else cv=new CIMValue((Sint32)ji);

if (notSigned)

return (jint)cv;

cv = new CIMValue ((Uint32)ji);

else

cv = new CIMValue ((Sint32)ji);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1long

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1long

(JNIEnv *jEnv, jobject jThs, jlong jl, jboolean notSigned) {

(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 (jint)cv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1float

if (notSigned)

(JNIEnv *jEnv, jobject jThs, jfloat jF) {

cv = new CIMValue ((Uint64)jl);

CIMValue *cv=new CIMValue(jF);

else

return (jint)cv;

cv = new CIMValue ((Sint64)jl);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1double

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

(JNIEnv *jEnv, jobject jThs, jdouble jD) {

CIMValue *cv=new CIMValue(jD);

return (jint)cv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1string

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1string

(JNIEnv *jEnv, jobject jThs, jstring jS) {

(JNIEnv *jEnv, jobject jThs, jstring jS)

{

const char *str=jEnv->GetStringUTFChars(jS,NULL);

CIMValue *cv=new CIMValue(String(str));

jEnv->ReleaseStringUTFChars(jS,str);

return (jint)cv;

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1boolean

(JNIEnv *jEnv, jobject jThs, jboolean jB)

{

CIMValue *cv = new CIMValue ((Boolean)jB);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

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);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1ref

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1double

(JNIEnv *jEnv, jobject jThs, jint jR) {

(JNIEnv *jEnv, jobject jThs, jdouble jD)

CIMObjectPath *ref=(CIMObjectPath*)jR;

{

CIMValue *cv = new CIMValue (jD);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1cop

(JNIEnv *jEnv, jobject jThs, jlong jR)

{

CIMObjectPath *ref = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jR);

CIMValue *cv=new CIMValue(*ref);

return (jint)cv;

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1datetime

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1datetime

(JNIEnv *jEnv, jobject jThs, jint jDT) {

(JNIEnv *jEnv, jobject jThs, jlong jDT)

CIMDateTime *dt=(CIMDateTime*)jDT;

{

CIMDateTime *dt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jDT);

CIMValue *cv=new CIMValue(*dt);

return (jint)cv;

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMValue__1isArray

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1char16

(JNIEnv *jEnv, jobject jThs, jint jP) {

(JNIEnv *jEnv, jobject jThs, jchar jChar16)

CIMValue *cv=(CIMValue*)jP;

{

return (jboolean)cv->isArray();

Char16 c16 (jChar16);

CIMValue *cv = new CIMValue (c16);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1boolean

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1object

(JNIEnv *jEnv, jobject jThs, jboolean jB) {

(JNIEnv *jEnv, jobject jThs, jlong jO)

CIMValue *cv=new CIMValue((Boolean)jB);

{

return (jint)cv;

CIMObject *co = DEBUG_ConvertJavaToC (jlong, CIMObject*, jO);

CIMValue *cv = new CIMValue (*co);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byteArray

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1byteArray

(JNIEnv *jEnv, jobject jThs, jshortArray jshortA, jboolean notSigned) {

(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) {

if (notSigned)

{

Array<Uint8> u8;

for (jsize i=0;i<len;i++)

u8.append((Uint8)jsA[i]);

cv=new CIMValue(u8);

}

else {

else

{

Array<Sint8> s8;

for (jsize i=0;i<len;i++)

s8.append((Sint8)jsA[i]);

cv=new CIMValue(s8);

}

return (jint)(void*)cv;

jEnv->ReleaseShortArrayElements (jshortA, jsA, len);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1shortArray

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1shortArray

(JNIEnv *jEnv, jobject jThs, jintArray jintA, jboolean notSigned) {

(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) {

if (notSigned)

{

Array<Uint16> u16;

for (jsize i=0;i<len;i++)

u16.append((Uint16)jiA[i]);

cv=new CIMValue(u16);

}

else {

else

{

Array<Sint16> s16;

for (jsize i=0;i<len;i++)

s16.append((Sint16)jiA[i]);

cv=new CIMValue(s16);

}

return (jint)(void*)cv;

jEnv->ReleaseIntArrayElements (jintA, jiA, len);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1intArray

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1intArray

(JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned) {

(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 (notSigned)

{

Array<Uint32> u32;

for (jsize i=0;i<len;i++)

u32.append((Uint32)jlA[i]);

cv=new CIMValue(u32);

}

else {

else

{

Array<Sint32> s32;

for (jsize i=0;i<len;i++)

s32.append((Sint32)jlA[i]);

cv=new CIMValue(s32);

}

return (jint)(void*)cv;

jEnv->ReleaseLongArrayElements (jlongA, jlA, len);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1longArray

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1longArray

(JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned) {

(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 (notSigned)

{

Array<Uint64> u64;

for (jsize i=0;i<len;i++)

u64.append((Uint64)jlA[i]);

cv=new CIMValue(u64);

}

else {

else

{

Array<Sint64> s64;

for (jsize i=0;i<len;i++)

s64.append((Sint64)jlA[i]);

cv=new CIMValue(s64);

}

return (jint)(void*)cv;

jEnv->ReleaseLongArrayElements (jlongA, jlA, len);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1stringArray

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1stringArray

(JNIEnv *jEnv, jobject jThs, jobjectArray jstringA) {

(JNIEnv *jEnv, jobject jThs, jobjectArray jstringA)

{

CIMValue *cv=NULL;

jboolean b;

jsize len=jEnv->GetArrayLength(jstringA);

Array<String> strA;

for (jsize i=0;i<len;i++) {

for (jsize i = 0;i < len; i++)

{

jstring jsA=(jstring)jEnv->GetObjectArrayElement(jstringA,i);

const char *str=jEnv->GetStringUTFChars(jsA,NULL);

strA.append(String(str));

jEnv->ReleaseStringUTFChars(jsA,str);

}

cv=new CIMValue(strA);

return (jint)(void*)cv;

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1booleanArray

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1booleanArray

(JNIEnv *jEnv, jobject jThs, jbooleanArray jboolA) {

(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++)

bA.append((Boolean)jbA[i]);

cv=new CIMValue(bA);

return (jint)(void*)cv;

jEnv->ReleaseBooleanArrayElements (jboolA, jbA, len);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1refArray

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1floatArray

(JNIEnv *jEnv, jobject jThs, jintArray jintA) {

(JNIEnv *jEnv, jobject jThs, jfloatArray jfloatA)

{

CIMValue *cv=NULL;

jboolean b;

jsize len=jEnv->GetArrayLength(jintA);

jsize len = jEnv->GetArrayLength (jfloatA);

jint* jiA=jEnv->GetIntArrayElements(jintA,&b);

jfloat *jfA = jEnv->GetFloatArrayElements (jfloatA, &b);

Array<float> fA;

for (jsize i = 0; i< len; i++)

fA.append ((float)jfA[i]);

cv = new CIMValue (fA);

jEnv->ReleaseFloatArrayElements (jfloatA, jfA, len);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1doubleArray

(JNIEnv *jEnv, jobject jThs, jdoubleArray jdoubleA)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength (jdoubleA);

jdouble *jdA = jEnv->GetDoubleArrayElements (jdoubleA, &b);

Array<double> dA;

for (jsize i = 0; i < len; i++)

dA.append ((double)jdA[i]);

cv = new CIMValue (dA);

jEnv->ReleaseDoubleArrayElements (jdoubleA, jdA, len);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1copArray

(JNIEnv *jEnv, jobject jThs, jlongArray jlongA)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength (jlongA);

jlong *jiA = jEnv->GetLongArrayElements (jlongA, &b);

Array<CIMObjectPath> cA;

for (jsize i=0;i<len;i++)

cA.append(*((CIMObjectPath*)jiA[i]));

{

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jiA[i]);

cA.append (*cop);

}

cv=new CIMValue(cA);

return (jint)(void*)cv;

jEnv->ReleaseLongArrayElements (jlongA, jiA, len);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1datetimeArray

(JNIEnv *jEnv, jobject jThs, jint jP) {

(JNIEnv *jEnv, jobject jThs, jlongArray jlongA)

CIMValue *cv=(CIMValue*)jP;

{

return (jint)pTypeToJType[cv->getType()];

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength (jlongA);

jlong *jiA = jEnv->GetLongArrayElements (jlongA, &b);

Array<CIMDateTime> cA;

for (jsize i = 0; i < len; i++)

{

CIMDateTime *cdt = DEBUG_ConvertJavaToC (jlong, CIMDateTime*, jiA[i]);

cA.append (*cdt);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString

cv = new CIMValue (cA);

(JNIEnv *jEnv, jobject jThs, jint jV) {

CIMValue *cv=(CIMValue*)jV;

jEnv->ReleaseLongArrayElements (jlongA, jiA, len);

return (jstring)jEnv->NewStringUTF(cv->toString().getCString());

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1objectArray

(JNIEnv *jEnv, jobject jThs, jlongArray jlongA)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength (jlongA);

jlong *jiA = jEnv->GetLongArrayElements (jlongA, &b);

Array<CIMObject> cA;

for (jsize i = 0; i < len; i++)

{

CIMObject *co = DEBUG_ConvertJavaToC (jlong, CIMObject*, jiA[i]);

cA.append (*co);

}

cv = new CIMValue (cA);

jEnv->ReleaseLongArrayElements (jlongA, jiA, len);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMValue__1char16Array

(JNIEnv *jEnv, jobject jThs, jcharArray jcharA)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength (jcharA);

jchar *jcA = jEnv->GetCharArrayElements (jcharA, &b);

Array<Char16> cA;

for (jsize i = 0; i < len; i++)

cA.append (Char16 (jcA[i]));

cv = new CIMValue (cA);

jEnv->ReleaseCharArrayElements (jcharA, jcA, len);

return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMValue__1getValue

(JNIEnv *jEnv, jobject jThs, jint jV) {

(JNIEnv *jEnv, jobject jThs, jlong jV)

CIMValue *cv=(CIMValue*)jV;

{

JMPIjvm::cacheIDs (jEnv);

CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);

if (cv->isNull())

return NULL;

CIMType type=cv->getType();

if (!cv->isArray()) {

if (!cv->isArray ())

switch (type) {

{

switch (type)

{

case CIMTYPE_BOOLEAN:

{

Boolean bo;

cv->get(bo);

return jEnv->NewObject(classRefs[1],instanceMethodIDs[1],bo);

return jEnv->NewObject (JMPIjvm::jv.BooleanClassRef,

break;

JMPIjvm::jv.BooleanNewZ,

(jboolean)bo);

}

case CIMTYPE_SINT8:

{

Sint8 s8;

cv->get(s8);

return jEnv->NewObject(classRefs[2],instanceMethodIDs[2],s8);

return jEnv->NewObject (JMPIjvm::jv.ByteClassRef,

break;

JMPIjvm::jv.ByteNewB,

(jbyte)s8);

}

case CIMTYPE_UINT8:

{

Uint8 u8;

cv->get(u8);

return jEnv->NewObject(classRefs[8],instanceMethodIDs[8],u8);

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef,

break;

JMPIjvm::jv.UnsignedInt8NewS,

(jshort)u8);

}

case CIMTYPE_SINT16:

{

Sint16 s16;

cv->get(s16);

return jEnv->NewObject(classRefs[3],instanceMethodIDs[3],s16);

return jEnv->NewObject (JMPIjvm::jv.ShortClassRef,

break;

JMPIjvm::jv.ShortNewS,

(jshort)s16);

}

case CIMTYPE_UINT16:

{

Uint16 u16;

cv->get(u16);

return jEnv->NewObject(classRefs[9],instanceMethodIDs[9],u16);

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef,

break;

JMPIjvm::jv.UnsignedInt16NewI,

(jint)u16);

}

case CIMTYPE_SINT32:

{

Sint32 s32;

cv->get(s32);

return jEnv->NewObject(classRefs[4],instanceMethodIDs[4],s32);

return jEnv->NewObject (JMPIjvm::jv.IntegerClassRef,

break;

JMPIjvm::jv.IntegerNewI,

(jint)s32);

}

case CIMTYPE_UINT32:

{

Uint32 u32;

cv->get(u32);

return jEnv->NewObject(classRefs[10],instanceMethodIDs[10],u32);

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef,

break;

JMPIjvm::jv.UnsignedInt32NewJ,

(jlong)u32);

}

case CIMTYPE_SINT64:

{

Sint64 s64;

cv->get(s64);

return jEnv->NewObject(classRefs[5],instanceMethodIDs[5],s64);

return jEnv->NewObject (JMPIjvm::jv.LongClassRef,

break;

JMPIjvm::jv.LongNewJ,

case CIMTYPE_UINT64: {

(jlong)s64);

}

case CIMTYPE_UINT64:

{

Uint64 u64;

cv->get(u64);

jobject big=jEnv->CallStaticObjectMethod(classRefs[14],staticMethodIDs[0],u64);

return jEnv->NewObject(classRefs[11],instanceMethodIDs[11],big);

std::ostringstream oss;

jstring jString = 0;

jobject jBIG = 0;

oss << u64 << ends;

jString = jEnv->NewStringUTF (oss.str ().c_str ());

if (jString)

{

jBIG = jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,

JMPIjvm::jv.UnsignedInt64NewStr,

jString);

}

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,

JMPIjvm::jv.UnsignedInt64NewBi,

jBIG);

}

break;

case CIMTYPE_REAL32:

{

float f;

cv->get(f);

return jEnv->NewObject(classRefs[6],instanceMethodIDs[6],f);

return jEnv->NewObject (JMPIjvm::jv.FloatClassRef,

break;

JMPIjvm::jv.FloatNewF,

(jfloat)f);

}

case CIMTYPE_REAL64:

{

double d;

cv->get(d);

return jEnv->NewObject(classRefs[7],instanceMethodIDs[7],d);

return jEnv->NewObject (JMPIjvm::jv.DoubleClassRef,

break;

JMPIjvm::jv.DoubleNewD,

case CIMTYPE_STRING: {

(jdouble)d);

}

case CIMTYPE_STRING:

{

String s;

jstring str;

cv->get(s);

str=jEnv->NewStringUTF(s.getCString());

return jEnv->NewStringUTF (s.getCString ());

return str;

}

break;

case CIMTYPE_REFERENCE:

case CIMTYPE_REFERENCE: {

{

CIMObjectPath ref;

cv->get(ref);

return jEnv->NewObject(classRefs[12],instanceMethodIDs[12],

jlong jOp = DEBUG_ConvertCToJava(

(jint)new CIMObjectPath(ref));

CIMObjectPath*,

jlong,

new CIMObjectPath (ref));

return jEnv->NewObject(

JMPIjvm::jv.CIMObjectPathClassRef,

JMPIjvm::jv.CIMObjectPathNewJ,

jOp);

}

break;

case CIMTYPE_CHAR16:

throwCIMException(jEnv,"+++ Char16 not yet supported");

{

break;

Char16 c16;

case CIMTYPE_DATETIME: {

cv->get (c16);

return jEnv->NewObject (JMPIjvm::jv.CharacterClassRef,

JMPIjvm::jv.CharacterNewC,

(jchar)c16);

}

case CIMTYPE_DATETIME:

{

CIMDateTime dt;

cv->get(dt);

return jEnv->NewObject(classRefs[24],instanceMethodIDs[35],

jlong jDT = DEBUG_ConvertCToJava(

(jint)new CIMDateTime(dt));

CIMDateTime*, jlong,

new CIMDateTime(dt));

return jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef,

JMPIjvm::jv.CIMDateTimeNewJ,

jDT);

}

// throwCIMException(jEnv,"+++ DateTime not yet supported");

break;

case CIMTYPE_OBJECT:

throwCIMException(jEnv,"+++ Object not yet supported");

{

break;

CIMObject co;

cv->get (co);

if (co.isClass ())

{

jlong jCC = DEBUG_ConvertCToJava(

CIMClass*,

jlong,

new CIMClass (co));

return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,

JMPIjvm::jv.CIMObjectNewJZ,

jCC,

(jboolean)true);

}

else

{

jlong jCI = DEBUG_ConvertCToJava(

CIMInstance*,

jlong,

new CIMInstance (co));

return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,

JMPIjvm::jv.CIMObjectNewJZ,

jCI,

(jboolean)false);

}

default:

throwCIMException(jEnv,"+++ unsupported type: ");

}

else

else {

{

switch (type) {

switch (type)

case CIMTYPE_BOOLEAN: {

{

case CIMTYPE_BOOLEAN:

{

Array<Boolean> bo;

cv->get(bo);

int s=bo.size();

jobjectArray jbooleanA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[1],0);

jobjectArray jbooleanA = (jobjectArray)jEnv->NewObjectArray(

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jbooleanA, i,

jEnv->NewObject(classRefs[1],instanceMethodIDs[1],bo[i]));

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;

}

break;

case CIMTYPE_SINT8:

case CIMTYPE_SINT8: {

{

Array<Sint8> s8;

cv->get(s8);

int s=s8.size();

jobjectArray jbyteA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[2],0);

jobjectArray jbyteA = (jobjectArray)jEnv->NewObjectArray(

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jbyteA, i,

jEnv->NewObject(classRefs[2],instanceMethodIDs[2],s8[i]));

JMPIjvm::jv.ByteClassRef,

0);

for (int i = 0; i < s; i++)

{

jEnv->SetObjectArrayElement(

jbyteA,

jEnv->NewObject(

JMPIjvm::jv.ByteClassRef,

JMPIjvm::jv.ByteNewB,

(jbyte)s8[i]));

}

return jbyteA;

}

break;

case CIMTYPE_UINT8:

case CIMTYPE_UINT8: {

{

Array<Uint8> u8;

cv->get(u8);

int s=u8.size();

jobjectArray jshortA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[8],0);

jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray(

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jshortA, i,

jEnv->NewObject(classRefs[8],instanceMethodIDs[8],u8[i]));

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;

}

break;

case CIMTYPE_SINT16:

case CIMTYPE_SINT16: {

{

Array<Sint16> s16;

cv->get(s16);

int s=s16.size();

jobjectArray jshortA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[3],0);

jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray(

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jshortA, i,

jEnv->NewObject(classRefs[3],instanceMethodIDs[3],s16[i]));

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;

}

break;

case CIMTYPE_UINT16:

case CIMTYPE_UINT16: {

{

Array<Uint16> u16;

cv->get(u16);

int s=u16.size();

jobjectArray jintA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[9],0);

jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray(

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jintA, i,

jEnv->NewObject(classRefs[9],instanceMethodIDs[9],u16[i]));

JMPIjvm::jv.UnsignedInt16ClassRef,

0);

for (int i = 0; i < s; i++)

{

jEnv->SetObjectArrayElement(

jintA,

jEnv->NewObject(

JMPIjvm::jv.UnsignedInt16ClassRef,

JMPIjvm::jv.UnsignedInt16NewI,

(jint)u16[i]));

}

return jintA;

}

break;

case CIMTYPE_SINT32:

case CIMTYPE_SINT32: {

{

Array<Sint32> s32;

cv->get(s32);

int s=s32.size();

jobjectArray jintA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[4],0);

jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray(

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jintA, i,

jEnv->NewObject(classRefs[4],instanceMethodIDs[4],s32[i]));

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;

}

break;

case CIMTYPE_UINT32:

case CIMTYPE_UINT32: {

{

Array<Uint32> u32;

cv->get(u32);

int s=u32.size();

jobjectArray jlongA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[10],0);

jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray(

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jlongA, i,

jEnv->NewObject(classRefs[10],instanceMethodIDs[10],u32[i]));

JMPIjvm::jv.UnsignedInt32ClassRef,

return jlongA;

0);

}

break;

case CIMTYPE_SINT64: {

Array<Sint64> s64;

cv->get(s64);

int s=s64.size();

jobjectArray jlongA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[5],0);

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jlongA, i,

jEnv->NewObject(classRefs[5],instanceMethodIDs[5],s64[i]));

return jlongA;

}

break;

case CIMTYPE_UINT64:

throwCIMException(jEnv,"+++ UnisgnetInt64 not yet supported");

break;

case CIMTYPE_REAL32: {

Array<Real32> r32;

cv->get(r32);

int s=r32.size();

jobjectArray jfloatA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[6],0);

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jfloatA, i,

jEnv->NewObject(classRefs[6],instanceMethodIDs[6],r32[i]));

return jfloatA;

}

break;

case CIMTYPE_REAL64: {

Array<Real64> r64;

cv->get(r64);

int s=r64.size();

jobjectArray jdoubleA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[7],0);

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jdoubleA, i,

jEnv->NewObject(classRefs[7],instanceMethodIDs[7],r64[i]));

return jdoubleA;

}

break;

case CIMTYPE_STRING: {

Array<String> str;

cv->get(str);

int s=str.size();

jobjectArray jstringA=(jobjectArray)jEnv->NewObjectArray(s,classRefs[22],0);

for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jstringA, i,

jEnv->NewStringUTF(str[i].getCString()));

return jstringA;

}

break;

case CIMTYPE_REFERENCE:

throwCIMException(jEnv,"+++ Reference not yet supported");

break;

case CIMTYPE_CHAR16:

throwCIMException(jEnv,"+++ Char16 not yet supported");

break;

case CIMTYPE_DATETIME:

throwCIMException(jEnv,"+++ DateTime not yet supported");

break;

case CIMTYPE_OBJECT:

throwCIMException(jEnv,"+++ Object not yet supported");

break;

default:

throwCIMException(jEnv,"+++ unsupported type: ");

}

return NULL;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMValue__1finalize

(JNIEnv *jEnv, jobject jThs, jint jV) {

CIMValue *cv=(CIMValue*)jV;

if (cv) delete cv;

}

// -------------------------------------

// ---

// - CIMNameSpace

// ---

// -------------------------------------

_nameSpace::_nameSpace() {

port_=0;

hostName_=System::getHostName();

nameSpace_="root/cimv2";

}

_nameSpace::_nameSpace(String hn) {

port_=0;

hostName_=hn;

nameSpace_="root/cimv2";

}

_nameSpace::_nameSpace(String hn, String ns) {

port_=0;

hostName_=hn;

nameSpace_=ns;

}

int _nameSpace::port() {

if (port_) return port_;

port_=5988;

if (hostName_.subString(0,7)=="http://") {

protocol_="http://";

hostName_=hostName_.subString(7);

}

Sint32 p=hostName_.reverseFind(':');

if (p>=0) {

if (isdigit(hostName_[p+1]))

port_=atoi(hostName_.subString(p+1).getCString());

hostName_.remove(p);

}

return port_;

}

String _nameSpace::hostName() {

port();

return hostName_;

}

String _nameSpace::nameSpace() {

for (int i = 0; i < s; i++)

return nameSpace_;

{

}

jEnv->SetObjectArrayElement(

jlongA,

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1new

jEnv->NewObject(

(JNIEnv *jEnv, jobject jThs) {

JMPIjvm::jv.UnsignedInt32ClassRef,

return (jint)(void*) new _nameSpace();

JMPIjvm::jv.UnsignedInt32NewJ,

}

(jlong)u32[i]));

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHn

(JNIEnv *jEnv, jobject jThs, jstring jHn) {

const char *hn=jEnv->GetStringUTFChars(jHn,NULL);

jint cInst=(jint)(void*)new _nameSpace(hn);

jEnv->ReleaseStringUTFChars(jHn,hn);

return cInst;

}

return jlongA;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHnNs

(JNIEnv *jEnv, jobject jThs, jstring jHn, jstring jNs) {

const char *hn=jEnv->GetStringUTFChars(jHn,NULL);

const char *ns=jEnv->GetStringUTFChars(jNs,NULL);

jint cInst=(jint)(void*)new _nameSpace(String(hn),String(ns));

jEnv->ReleaseStringUTFChars(jHn,hn);

jEnv->ReleaseStringUTFChars(jNs,ns);

return cInst;

}

case CIMTYPE_SINT64:

{

Array<Sint64> s64;

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getHost

cv->get (s64);

(JNIEnv *jEnv, jobject jThs, jint jNs) {

_nameSpace *cNs=(_nameSpace*)jNs;

const String &hn=cNs->hostName_;

jstring str=jEnv->NewStringUTF(hn.getCString());

return str;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getNameSpace

int s = s64.size ();

(JNIEnv *jEnv, jobject jThs, jint jNs) {

jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray(

_nameSpace *cNs=(_nameSpace*)jNs;

const String &ns=cNs->nameSpace_;

JMPIjvm::jv.LongClassRef,

jstring str=jEnv->NewStringUTF(ns.getCString());

0);

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setHost

for (int i = 0; i < s; i++)

(JNIEnv *jEnv, jobject jThs, jint jNs, jstring jHn) {

{

_nameSpace *cNs=(_nameSpace*)jNs;

jEnv->SetObjectArrayElement(

const char *str=jEnv->GetStringUTFChars(jHn,NULL);

jlongA,

cNs->port_=0;

cNs->hostName_=str;

jEnv->NewObject(

jEnv->ReleaseStringUTFChars(jHn,str);

JMPIjvm::jv.LongClassRef,

JMPIjvm::jv.LongNewJ,

(jlong)s64[i]));

}

return jlongA;

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setNameSpace

(JNIEnv *jEnv, jobject jThs, jint jNs, jstring jN) {

_nameSpace *cNs=(_nameSpace*)jN;

const char *str=jEnv->GetStringUTFChars(jN,NULL);

cNs->nameSpace_=str;

jEnv->ReleaseStringUTFChars(jN,str);

}

case CIMTYPE_UINT64:

{

Array<Uint64> u64;

cv->get (u64);

int s = u64.size ();

jobjectArray ju64A = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.UnsignedInt64ClassRef,

0);

for (int i = 0; i < s; i++)

{

std::ostringstream oss;

jstring jString = 0;

jobject jBIG = 0;

// -------------------------------------

oss << u64[i] << ends;

// ---

// - Enumerators

// ---

// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1getClass

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) {

Array<CIMClass> *enm=(Array<CIMClass>*)jEnum;

return (jint) new CIMClass((*enm)[pos]);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1size

(JNIEnv *jEnv, jobject jThs, jint jEnum) {

Array<CIMClass> *enm=(Array<CIMClass>*)jEnum;

return enm->size();

}

jString = jEnv->NewStringUTF (oss.str ().c_str ());

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1getInstance

if (jString)

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) {

{

Array<CIMInstance> *enm=(Array<CIMInstance>*)jEnum;

jBIG = jEnv->NewObject(

return (jint) new CIMInstance((*enm)[pos]);

JMPIjvm::jv.UnsignedInt64ClassRef,

JMPIjvm::jv.UnsignedInt64NewStr,

jString);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1size

if (jBIG)

(JNIEnv *jEnv, jobject jThs, jint jEnum) {

{

Array<CIMInstance> *enm=(Array<CIMInstance>*)jEnum;

jEnv->SetObjectArrayElement(

return enm->size();

ju64A,

jEnv->NewObject(

JMPIjvm::jv.UnsignedInt64ClassRef,

JMPIjvm::jv.UnsignedInt64NewBi,

jBIG));

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1getObjectPath

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) {

Array<CIMObjectPath> *enm=(Array<CIMObjectPath>*)jEnum;

return (jint) new CIMObjectPath((*enm)[pos]);

}

return ju64A;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1size

(JNIEnv *jEnv, jobject jThs, jint jEnum) {

Array<CIMObjectPath> *enm=(Array<CIMObjectPath>*)jEnum;

return enm->size();

}

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_QualEnumeration__1getQualifierType

for (int i = 0; i < s; i++)

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) {

{

Array<CIMQualifierDecl> *enm=(Array<CIMQualifierDecl>*)jEnum;

jEnv->SetObjectArrayElement(

return (jint) new CIMQualifierDecl((*enm)[pos]);

jfloatA,

jEnv->NewObject(

JMPIjvm::jv.FloatClassRef,

JMPIjvm::jv.FloatNewF,

(jfloat)r32[i]));

}

return jfloatA;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1size

(JNIEnv *jEnv, jobject jThs, jint jEnum) {

Array<CIMQualifierDecl> *enm=(Array<CIMQualifierDecl>*)jEnum;

return enm->size();

}

case CIMTYPE_REAL64:

{

Array<Real64> r64;

cv->get (r64);

int s = r64.size ();

jobjectArray jdoubleA = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.DoubleClassRef,

0);

// -------------------------------------

for (int i = 0; i < s; i++)

// ---

{

// - CIMClient

jEnv->SetObjectArrayElement(

// ---

jdoubleA,

// -------------------------------------

jEnv->NewObject(

JMPIjvm::jv.DoubleClassRef,

JMPIjvm::jv.DoubleNewD,

(jdouble)r64[i]));

}

return jdoubleA;

}

case CIMTYPE_STRING:

{

Array<String> str;

cv->get(str);

int s = str.size ();

jobjectArray jstringA = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.StringClassRef,

0);

void checkNs(CIMObjectPath *cop, jint jNs) {

for (int i = 0; i < s; i++)

if (cop->getNameSpace().isNull()) {

{

_nameSpace *ns=(_nameSpace*)jNs;

jEnv->SetObjectArrayElement(

cop->setNameSpace(CIMNamespaceName(ns->nameSpace()));

jstringA,

jEnv->NewStringUTF (str[i].getCString ()));

}

return jstringA;

}

case CIMTYPE_REFERENCE:

{

Array<CIMObjectPath> ref;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1newNaUnPw

cv->get (ref);

(JNIEnv *jEnv, jobject jThs, jint jNs, jstring jUn, jstring jPw) {

_nameSpace *cNs=(_nameSpace*)jNs;

const char *un=jEnv->GetStringUTFChars(jUn,NULL);

int s = ref.size ();

const char *pw=jEnv->GetStringUTFChars(jPw,NULL);

jobjectArray jrefA = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.CIMObjectPathClassRef,

0);

try {

for (int i = 0; i < s; i++)

JMPIjvm::cacheIDs(jEnv);

{

CIMClient *cc=new CIMClient();

jlong jOP = DEBUG_ConvertCToJava(

cc->connect(cNs->hostName(),cNs->port(),un,pw);

CIMObjectPath*,

jEnv->ReleaseStringUTFChars(jUn,un);

jlong,

jEnv->ReleaseStringUTFChars(jPw,pw);

new CIMObjectPath(ref[i]));

return (jint)(void*)cc;

jEnv->SetObjectArrayElement (jrefA,

jEnv->NewObject(

JMPIjvm::jv.CIMObjectPathClassRef,

JMPIjvm::jv.CIMObjectPathNewJ,

jOP));

}

Catch(jEnv);

return jrefA;

return 0;

}

case CIMTYPE_CHAR16:

{

Array<Char16> c16;

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1disconnect

cv->get (c16);

(JNIEnv *jEnv, jobject jThs, jint jCc) {

CIMClient *cCc=(CIMClient*)jCc;

try {

cCc->disconnect();

}

Catch(jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getClass

int s = c16.size ();

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean lo,

jobjectArray jc16A = (jobjectArray)jEnv->NewObjectArray(

jboolean iq, jboolean ic, jobjectArray jPl) {

CIMClient *cCc=(CIMClient*)jCc;

JMPIjvm::jv.CharacterClassRef,

CIMObjectPath *cop=(CIMObjectPath*)jCop;

0);

CIMPropertyList pl=getList(jEnv,jPl);

try {

checkNs(cop,jNs);

CIMClass cls=cCc->getClass(cop->getNameSpace(),cop->getClassName(),(Boolean)lo,

(Boolean)iq,(Boolean)ic,pl);

return (jint) new CIMClass(cls);

}

Catch(jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteClass

for (int i = 0; i < s; i++)

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop) {

{

CIMClient *cCc=(CIMClient*)jCc;

jEnv->SetObjectArrayElement(

CIMObjectPath *cop=(CIMObjectPath*)jCop;

jc16A,

try {

checkNs(cop,jNs);

jEnv->NewObject(

cCc->deleteClass(cop->getNameSpace(),cop->getClassName());

JMPIjvm::jv.CharacterClassRef,

JMPIjvm::jv.CharacterNewC,

(jchar)c16[i]));

}

Catch(jEnv);

return jc16A;

return;

}

case CIMTYPE_DATETIME:

{

Array<CIMDateTime> dt;

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createClass

cv->get (dt);

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, int jCl) {

CIMClient *cCc=(CIMClient*)jCc;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMClass *cl=(CIMClass*)jCl;

try {

int s = dt.size ();

cCc->createClass(cop->getNameSpace(),*cl);

jobjectArray jdtA = (jobjectArray)jEnv->NewObjectArray(

JMPIjvm::jv.CIMDateTimeClassRef,

0);

for (int i = 0; i < s; i++)

{

jlong jDT = DEBUG_ConvertCToJava(

CIMDateTime*,

jlong,

new CIMDateTime (dt[i]));

jEnv->SetObjectArrayElement(

jdtA,

jEnv->NewObject(

JMPIjvm::jv.CIMDateTimeClassRef,

JMPIjvm::jv.CIMDateTimeNewJ,

jDT));

}

Catch(jEnv);

return jdtA;

return;

}

case CIMTYPE_OBJECT:

{

Array<CIMObject> co;

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setClass

cv->get (co);

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jCl) {

CIMClient *cCc=(CIMClient*)jCc;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMClass *cl=(CIMClass*)jCl;

try {

int s = co.size ();

checkNs(cop,jNs);

jobjectArray jcoA = (jobjectArray)jEnv->NewObjectArray(

cCc->modifyClass(cop->getNameSpace(),*cl);

}

JMPIjvm::jv.CIMObjectClassRef,

Catch(jEnv);

0);

return ;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClasses

for (int i = 0; i < s; i++)

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, int jCop, jboolean deep, jboolean lo, jboolean iq, jboolean ic) {

{

CIMClient *cCc=(CIMClient*)jCc;

if (co[i].isClass ())

CIMObjectPath *cop=(CIMObjectPath*)jCop;

{

try {

jlong jCC = DEBUG_ConvertCToJava(

checkNs(cop,jNs);

CIMClass*,

Array<CIMClass> enm=cCc->enumerateClasses(

jlong,

cop->getNameSpace(),cop->getClassName(),(Boolean)deep,(Boolean)lo,(Boolean)iq,(Boolean)ic);

new CIMClass (co[i]));

return (jint) new Array<CIMClass>(enm);

}

jEnv->SetObjectArrayElement(

Catch(jEnv);

jcoA,

return 0;

jEnv->NewObject(

JMPIjvm::jv.CIMObjectClassRef,

JMPIjvm::jv.CIMObjectNewJZ,

jCC,

(jboolean)true));

}

else

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClassNames

{

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep) {

jlong jCI = DEBUG_ConvertCToJava(

CIMClient *cCc=(CIMClient*)jCc;

CIMInstance*,

CIMObjectPath *cop=(CIMObjectPath*)jCop;

jlong,

CIMNamespaceName ns=cop->getNameSpace();

new CIMInstance (co[i]));

try {

checkNs(cop,jNs);

jEnv->SetObjectArrayElement(

Array<CIMName> enm=cCc->enumerateClassNames(ns,cop->getClassName(),(Boolean)deep);

jcoA,

Array<CIMObjectPath> *enmop=new Array<CIMObjectPath>();

for (int i=0,m=enm.size(); i<m; i++) {

jEnv->NewObject(

enmop->append(CIMObjectPath(String::EMPTY,ns,enm[i]));

JMPIjvm::jv.CIMObjectClassRef,

JMPIjvm::jv.CIMObjectNewJZ,

jCI,

(jboolean)false));

}

return (jint)enmop;

}

Catch(jEnv);

return jcoA;

return 0;

}

default:

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateQualifiers

throwCIMException (jEnv,"+++ unsupported type: ");

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, int jCop) {

CIMClient *cCc=(CIMClient*)jCc;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

try {

checkNs(cop,jNs);

Array<CIMQualifierDecl> enm=cCc->enumerateQualifiers(

cop->getNameSpace());

return (jint) new Array<CIMQualifierDecl>(enm);

}

Catch(jEnv);

return 0;

}

return NULL;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType

(JNIEnv *jEnv, jobject jThs, jlong jP)

{

CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jP);

bool fSuccess = false;

jint jiJType = 0;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getInstance

jiJType = _dataType::convertCTypeToJavaType (cv->getType (), &fSuccess);

(JNIEnv *jEnv, jobject jThs, jint jCc, int jNs, int jCop, jboolean lo,

jboolean iq, jboolean ic, jobjectArray jPl) {

CIMClient *cCc=(CIMClient*)jCc;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMPropertyList pl=getList(jEnv,jPl);

try {

return jiJType;

checkNs(cop,jNs);

CIMInstance inst=cCc->getInstance(cop->getNameSpace(),*cop,(Boolean)lo,

(Boolean)iq,(Boolean)ic,pl);

return (jint) new CIMInstance(inst);

}

Catch(jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteInstance

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMValue__1isArray

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop) {

(JNIEnv *jEnv, jobject jThs, jlong jP)

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jP);

try {

checkNs(cop,jNs);

cCc->deleteInstance(cop->getNameSpace(),*cop);

}

Catch(jEnv);

return;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1createInstance

return (jboolean)cv->isArray ();

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, int jCi) {

CIMClient *cCc=(CIMClient*)jCc;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMInstance *ci=(CIMInstance*)jCi;

try {

checkNs(cop,jNs);

ci->setPath(*cop);

CIMObjectPath obj=cCc->createInstance(cop->getNameSpace(),*ci);

return (jint) new CIMObjectPath(obj);

}

Catch(jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1modifyInstance

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jCi,

(JNIEnv *jEnv, jobject jThs, jlong jV)

jboolean iq, jobjectArray jPl) {

{

CIMClient *cCc=(CIMClient*)jCc;

CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMInstance *ci=(CIMInstance*)jCi;

CIMPropertyList pl=getList(jEnv,jPl);

try {

checkNs(cop,jNs);

ci->setPath(*cop);

cCc->modifyInstance(cop->getNameSpace(),*ci,(Boolean)iq,pl);

}

Catch(jEnv);

return ;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstances

return (jstring)jEnv->NewStringUTF (cv->toString ().getCString ());

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep, jboolean lo,

jboolean iq, jboolean ic, jobjectArray jPl) {

CIMClient *cCc=(CIMClient*)jCc;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMPropertyList pl=getList(jEnv,jPl);

try {

checkNs(cop,jNs);

CIMPropertyList props;

Array<CIMInstance> enm=cCc->enumerateInstances(

cop->getNameSpace(),cop->getClassName(),(Boolean)deep,(Boolean)lo,(Boolean)iq,(Boolean)ic,pl);

return (jint) new Array<CIMInstance>(enm);

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstanceNames

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMValue__1finalize

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep) {

(JNIEnv *jEnv, jobject jThs, jlong jV)

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMValue *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);

try {

checkNs(cop,jNs);

Array<CIMObjectPath> enm=cCc->enumerateInstanceNames(

cop->getNameSpace(),cop->getClassName()); //,(Boolean)deep);

return (jint) new Array<CIMObjectPath>(enm);

}

Catch(jEnv);

return 0;

}

delete cv;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getQualifier

DEBUG_ConvertCleanup (jlong, jV);

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop) {

CIMClient *cCc=(CIMClient*)jCc;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

try {

checkNs(cop,jNs);

CIMQualifierDecl *val=new CIMQualifierDecl(cCc->getQualifier(cop->getNameSpace(),cop->getClassName()));

return (jint)val;

}

Catch(jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteQualifier

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop) {

CIMClient *cCc=(CIMClient*)jCc;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

try {

checkNs(cop,jNs);

cCc->deleteQualifier(cop->getNameSpace(),cop->getClassName());

}

Catch(jEnv);

return;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setQualifier

// -------------------------------------

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jQ) {

// ---

CIMClient *cCc=(CIMClient*)jCc;

// - ClassEnumeration

CIMObjectPath *cop=(CIMObjectPath*)jCop;

// ---

CIMQualifierDecl *qt=(CIMQualifierDecl*)jQ;

// -------------------------------------

try {

checkNs(cop,jNs);

cCc->setQualifier(cop->getNameSpace(),*qt);

}

Catch(jEnv);

return;

}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1getClass

(JNIEnv *jEnv, jobject jThs, jlong jEnum, jint pos)

{

Array<CIMClass> *enm = DEBUG_ConvertJavaToC(jlong, Array<CIMClass>*, jEnum);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty

return DEBUG_ConvertCToJava (CIMClass*, jlong, new CIMClass ((*enm)[pos]));

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn) {

CIMClient *cCc=(CIMClient*)jCc;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

const char *str=jEnv->GetStringUTFChars(jPn,NULL);

CIMName pName(str);

jEnv->ReleaseStringUTFChars(jPn,str);

try {

checkNs(cop,jNs);

CIMValue *val=new CIMValue(cCc->getProperty(cop->getNameSpace(),*cop,pName));

return (jint)val;

}

Catch(jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1size

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn, jint jV) {

(JNIEnv *jEnv, jobject jThs, jlong jEnum)

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

Array<CIMClass> *enm = DEBUG_ConvertJavaToC(jlong, Array<CIMClass>*, jEnum);

CIMValue *val=(CIMValue*)jCop;

const char *str=jEnv->GetStringUTFChars(jPn,NULL);

return enm->size ();

CIMName pName(str);

jEnv->ReleaseStringUTFChars(jPn,str);

try {

checkNs(cop,jNs);

cCc->setProperty(cop->getNameSpace(),*cop,pName,*val);

}

Catch(jEnv);

return;

// -------------------------------------

// ---

// - InstEnumeration

// ---

// -------------------------------------

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_InstEnumeration__1getInstance

(JNIEnv *jEnv, jobject jThs, jlong jEnum, jint pos)

{

Array<CIMInstance> *enm = DEBUG_ConvertJavaToC(

jlong,

Array<CIMInstance>*,

jEnum);

return DEBUG_ConvertCToJava(

CIMInstance*,

jlong,

new CIMInstance((*enm)[pos]));

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1size

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn, jobject jIn, jobject jOut) {

(JNIEnv *jEnv, jobject jThs, jlong jEnum)

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

Array<CIMInstance> *enm = DEBUG_ConvertJavaToC(

const char *str=jEnv->GetStringUTFChars(jMn,NULL);

jlong,

CIMName method(str);

Array<CIMInstance>*,

jEnv->ReleaseStringUTFChars(jMn,str);

jEnum);

Array<CIMParamValue> in;

return enm->size ();

Array<CIMParamValue> out;

}

for (int i=0,m=jEnv->CallIntMethod(jIn,instanceMethodIDs[28]); i<m; i++) {

// -------------------------------------

JMPIjvm::checkException(jEnv);

// ---

jobject jProp=jEnv->CallObjectMethod(jIn,instanceMethodIDs[16],i);

// - JMPIQueryExp

JMPIjvm::checkException(jEnv);

// ---

CIMProperty *p=((CIMProperty*)jEnv->CallIntMethod(jProp,instanceMethodIDs[29]));

// -------------------------------------

JMPIjvm::checkException(jEnv);

in.append(CIMParamValue(p->getName().getString(),p->getValue()));

* 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);

if ( !wql_stmt

|| !ci

)

{

return 0;

}

try {

checkNs(cop,jNs);

CIMValue *val=new CIMValue(cCc->invokeMethod(cop->getNameSpace(),*cop,method,in,out));

for (int i=0,m=out.size(); i<m; i++) {

try

const CIMParamValue & parm=out[i];

{

const CIMValue v=parm.getValue();

return wql_stmt->evaluate (*ci);

CIMProperty *p=new CIMProperty(parm.getParameterName(),v,v.getArraySize());

jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)p);

jEnv->CallVoidMethod(jOut,instanceMethodIDs[15],prop);

}

return (jint)val;

catch (const Exception &e)

{

cerr << "Java_org_pegasus_jmpi_JMPIQueryExp__1applyInstance: Caught: "

<< e.getMessage () << endl;

return false;

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod24

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn,

jobjectArray jIn, jobjectArray jOut) {

CIMClient *cCc=(CIMClient*)jCc;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

const char *str=jEnv->GetStringUTFChars(jMn,NULL);

CIMName method(str);

jEnv->ReleaseStringUTFChars(jMn,str);

Array<CIMParamValue> in;

// -------------------------------------

Array<CIMParamValue> out;

// ---

// - JMPISelectList

// ---

// -------------------------------------

for (int i=0,m=jEnv->GetArrayLength(jIn); i<m; i++) {

JMPIjvm::checkException(jEnv);

* Class: org_pegasus_jmpi_JMPISelectList

jobject jArg=jEnv->GetObjectArrayElement(jIn,i);

* Method: _applyInstance

JMPIjvm::checkException(jEnv);

* Signature: (II)I

CIMParamValue *p=((CIMParamValue*)jEnv->CallIntMethod(jArg,instanceMethodIDs[39]));

JMPIjvm::checkException(jEnv);

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyInstance

in.append(*p);

(JNIEnv *jEnv, jobject jThs, jlong jWQLStmt, jlong jciInstance)

{

WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC(

jlong,

WQLSelectStatement*,

jWQLStmt);

CIMInstance *ci = DEBUG_ConvertJavaToC(

jlong,

CIMInstance*,

jciInstance);

CIMInstance *ciRet = 0;

if ( !wql_stmt

|| !ci

)

{

return 0;

}

try {

checkNs(cop,jNs);

CIMValue *val=new CIMValue(cCc->invokeMethod(cop->getNameSpace(),*cop,method,in,out));

for (int i=0,m=out.size(),o=jEnv->GetArrayLength(jOut); i<m && i<o; i++) {

ciRet = new CIMInstance (ci->clone ());

const CIMParamValue & parm=out[i];

jEnv->SetObjectArrayElement(jOut,i,

if (ciRet)

jEnv->NewObject(classRefs[29],instanceMethodIDs[40],(jint)&parm));

{

}

try

return (jint)val;

{

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_CIMClient__1execQuery

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jQuery, jstring jQl) {

* Class: org_pegasus_jmpi_JMPISelectList

CIMClient *cCc=(CIMClient*)jCc;

* Method: _applyClass

CIMObjectPath *cop=(CIMObjectPath*)jCop;

* Signature: (II)I

const char *str=jEnv->GetStringUTFChars(jQuery,NULL);

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyClass

String query(str);

(JNIEnv *jEnv, jobject jThs, jlong jWQLStmt, jlong jciClass)

jEnv->ReleaseStringUTFChars(jQuery,str);

{

str=jEnv->GetStringUTFChars(jQl,NULL);

WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC(

String ql(str);

jlong,

jEnv->ReleaseStringUTFChars(jQl,str);

WQLSelectStatement*,

jWQLStmt);

CIMClass *cc = DEBUG_ConvertJavaToC(

jlong,

CIMClass*,

jciClass);

CIMClass *ccRet = NULL;

try {

if (!wql_stmt)

checkNs(cop,jNs);

{

Array<CIMObject> enm=cCc->execQuery(

return 0;

cop->getNameSpace(),query,ql);

Array<CIMInstance> *enmInst=new Array<CIMInstance>();

for (int i=0,m=enm.size(); i<m; i++) {

enmInst->append(CIMInstance(enm[i]));

}

return (jint)enmInst;

if (cc)

{

CIMObject co (cc->clone ());

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 jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associatorNames

ccRet = new CIMClass (co);

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,

jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole) {

CIMClient *cCc=(CIMClient*)jCc;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

const char *str=jEnv->GetStringUTFChars(jAssocClass,NULL);

CIMName assocClass(str);

jEnv->ReleaseStringUTFChars(jAssocClass,str);

str=jEnv->GetStringUTFChars(jResultClass,NULL);

CIMName resultClass(str);

jEnv->ReleaseStringUTFChars(jResultClass,str);

str=jEnv->GetStringUTFChars(jRole,NULL);

String role(str);

jEnv->ReleaseStringUTFChars(jRole,str);

str=jEnv->GetStringUTFChars(jResultRole,NULL);

String resultRole(str);

jEnv->ReleaseStringUTFChars(jResultRole,str);

try {

return DEBUG_ConvertCToJava (CIMClass *, jlong, ccRet);

checkNs(cop,jNs);

Array<CIMObjectPath> enm=cCc->associatorNames(

cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole);

return (jint) new Array<CIMObjectPath>(enm);

}

Catch(jEnv);

return 0;

}

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=(CIMClient*)jCc;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMPropertyList pl=getList(jEnv,jPl);

const char *str=jEnv->GetStringUTFChars(jAssocClass,NULL);

// -------------------------------------

CIMName assocClass(str);

// ---

jEnv->ReleaseStringUTFChars(jAssocClass,str);

// - OperationContext

str=jEnv->GetStringUTFChars(jResultClass,NULL);

// ---

CIMName resultClass(str);

// -------------------------------------

jEnv->ReleaseStringUTFChars(jResultClass,str);

str=jEnv->GetStringUTFChars(jRole,NULL);

String role(str);

* Class: OperationContext

jEnv->ReleaseStringUTFChars(jRole,str);

* Method: _get

str=jEnv->GetStringUTFChars(jResultRole,NULL);

* Signature: (ILjava/lang/String;Ljava/lang/String;)Ljava/lang/Object;

String resultRole(str);

jEnv->ReleaseStringUTFChars(jResultRole,str);

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_OperationContext__1get

(JNIEnv *jEnv, jobject jThs, jlong jInst, jstring jContainer, jstring jKey)

{

OperationContext *poc = DEBUG_ConvertJavaToC(

jlong,

OperationContext*,

jInst);

jobject jRet = 0;

if (!poc)

{

return jRet;

}

const char *pszContainer = jEnv->GetStringUTFChars (jContainer, NULL);

const char *pszKey = jEnv->GetStringUTFChars (jKey, NULL);

String container (pszContainer);

String key (pszKey);

try {

checkNs(cop,jNs);

if (container == "IdentityContainer")

Array<CIMObject> enm=cCc->associators(

{

cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole,

IdentityContainer ic = poc->get(IdentityContainer::NAME);

(Boolean)includeQualifiers,(Boolean)includeClassOrigin,pl);

if (key == "userName")

Array<CIMInstance> *enmInst=new Array<CIMInstance>();

{

for (int i=0,m=enm.size(); i<m; i++) {

String userName = ic.getUserName();

enmInst->append(CIMInstance(enm[i]));

jRet = jEnv->NewStringUTF((const char*)userName.getCString());

}

return (jint)enmInst;

}

Catch(jEnv);

else if (container == "SubscriptionInstanceContainer")

return 0;

{

SubscriptionInstanceContainer sic =

poc->get(SubscriptionInstanceContainer::NAME);

if (key == "subscriptionInstance")

{

CIMInstance ci = sic.getInstance ();

jlong jciRef = DEBUG_ConvertCToJava(

CIMInstance*,

jlong,

new CIMInstance (ci));

jRet = jEnv->NewObject (JMPIjvm::jv.CIMInstanceClassRef,

JMPIjvm::jv.CIMInstanceNewJ,

jciRef);

}

else if (container == "SubscriptionInstanceNamesContainer")

{

SubscriptionInstanceNamesContainer sinc=

poc->get (SubscriptionInstanceNamesContainer::NAME);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1referenceNames

if (key == "subscriptionInstanceNames")

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,

{

jstring jAssocClass, jstring jRole) {

Array<CIMObjectPath> copa = sinc.getInstanceNames ();

CIMClient *cCc=(CIMClient*)jCc;

jobjectArray jcopa = 0;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

int jcopaLength = copa.size ();

jcopa = (jobjectArray)jEnv->NewObjectArray(

jcopaLength,

JMPIjvm::jv.CIMObjectPathClassRef,

0);

const char *str=jEnv->GetStringUTFChars(jAssocClass,NULL);

for (int i = 0; i < jcopaLength; i++)

CIMName assocClass(str);

{

jEnv->ReleaseStringUTFChars(jAssocClass,str);

jEnv->SetObjectArrayElement(

str=jEnv->GetStringUTFChars(jRole,NULL);

jcopa,

String role(str);

jEnv->ReleaseStringUTFChars(jRole,str);

jEnv->NewObject(

JMPIjvm::jv.CIMObjectPathClassRef,

JMPIjvm::jv.CIMObjectPathNewJ,

new CIMObjectPath(copa[i])));

}

try {

jRet = (jobject)jcopa;

checkNs(cop,jNs);

Array<CIMObjectPath> enm=cCc->referenceNames(

cop->getNameSpace(),*cop,assocClass,role);

return (jint) new Array<CIMObjectPath>(enm);

}

Catch(jEnv);

return 0;

}

else if (container == "SubscriptionFilterConditionContainer")

{

SubscriptionFilterConditionContainer sfcc =

poc->get (SubscriptionFilterConditionContainer::NAME);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1references

if (key == "filterCondition")

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,

{

jstring jAssocClass, jstring jRole,

String filterCondition = sfcc.getFilterCondition ();

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl) {

CIMClient *cCc=(CIMClient*)jCc;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMPropertyList pl=getList(jEnv,jPl);

const char *str=jEnv->GetStringUTFChars(jAssocClass,NULL);

jRet=jEnv->NewStringUTF((const char*)filterCondition.getCString());

CIMName assocClass(str);

}

jEnv->ReleaseStringUTFChars(jAssocClass,str);

else if (key == "queryLanguage")

str=jEnv->GetStringUTFChars(jRole,NULL);

{

String role(str);

String queryLanguage = sfcc.getQueryLanguage ();

jEnv->ReleaseStringUTFChars(jRole,str);

try {

jRet=jEnv->NewStringUTF((const char*)queryLanguage.getCString ());

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]));

}

return (jint)enmInst;

}

Catch(jEnv);

else if (container == "SubscriptionFilterQueryContainer")

return 0;

{

SubscriptionFilterQueryContainer sfqc =

poc->get(SubscriptionFilterQueryContainer::NAME);

if (key == "filterQuery")

{

String filterQuery = sfqc.getFilterQuery ();

jRet = jEnv->NewStringUTF ((const char*)filterQuery.getCString ());

}

else if (key == "queryLanguage")

{

String queryLanguage = sfqc.getQueryLanguage ();

static int normalizeNs(String &ns, String &nsBase, String &lastNsComp) {

jRet = jEnv->NewStringUTF((const char*)queryLanguage.getCString());

Uint32 n=ns.size();

if (ns[n-1]=='/') {

if (n>=2) ns=ns.subString(0,n-2);

}

else if (key == "sourceNameSpace")

{

CIMNamespaceName cimNameSpaceName = sfqc.getSourceNameSpace();

String nameSpaceName = cimNameSpaceName.getString();

lastNsComp=ns;

jRet = jEnv->NewStringUTF((const char*)nameSpaceName.getCString());

nsBase="root";

}

else if (container == "SnmpTrapOidContainer")

{

SnmpTrapOidContainer stoc = poc->get (SnmpTrapOidContainer::NAME);

n=ns.reverseFind('/');

if (key == "snmpTrapOid")

if (n!=PEG_NOT_FOUND) {

{

lastNsComp=ns.subString(n+1);

String snmpTrapOid = stoc.getSnmpTrapOid ();

nsBase=ns.subString(0,n);

jRet = jEnv->NewStringUTF ((const char*)snmpTrapOid.getCString ());

}

return 0;

}

Catch (jEnv);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createNameSpace

///printf ("jRet: %08X\n", (int)jRet);

(JNIEnv *jEnv, jobject jThs, jint jCc, jstring jNs) {

CIMClient *cCc=(CIMClient*)jCc;

const char* str=jEnv->GetStringUTFChars(jNs,NULL);

jEnv->ReleaseStringUTFChars (jContainer, pszContainer);

String ns(str);

jEnv->ReleaseStringUTFChars (jKey, pszKey);

jEnv->ReleaseStringUTFChars(jNs,str);

String lastNsComp;

return jRet;

String nsBase;

}

normalizeNs(ns,nsBase,lastNsComp);

CIMInstance newInstance(CIMName("__Namespace"));

// -------------------------------------

newInstance.addProperty(CIMProperty(CIMName ("name"),lastNsComp));

// ---

// - PathEnumeration

// ---

// -------------------------------------

try {

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_PathEnumeration__1getObjectPath

cCc->createInstance(CIMNamespaceName(nsBase),newInstance);

(JNIEnv *jEnv, jobject jThs, jlong jEnum, jint pos)

}

{

Catch(jEnv);

Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC(

return;

jlong,

Array<CIMObjectPath>*,

jEnum);

return DEBUG_ConvertCToJava(

CIMObjectPath*,

jlong,

new CIMObjectPath((*enm)[pos]));

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateNameSpaces

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1size

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jboolean deep, jobject jVec) {

(JNIEnv *jEnv, jobject jThs, jlong jEnum)

{

Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC(

jlong,

Array<CIMObjectPath>*,

jEnum);

CIMClient *cCc=(CIMClient*)jCc;

return enm->size ();

CIMObjectPath *cop=(CIMObjectPath*)jCop;

String ns=cop->getNameSpace().getString();

try {

Array<CIMObjectPath> enm=cCc->enumerateInstanceNames(

cop->getNameSpace(),CIMName("__Namespace"));

for (int i=0,s=enm.size(); i<s; i++) {

CIMObjectPath &cop=enm[i];

const Array<CIMKeyBinding>& kb=cop.getKeyBindings();

const String &n=kb[0].getValue();

if (!deep && n.find('/')!=PEG_NOT_FOUND) continue;

String x=ns+"/"+n;

jstring str=jEnv->NewStringUTF(x.getCString());

jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],str);

}

// -------------------------------------

// ---

// - 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]));

}

Catch(jEnv);

return jVec;

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 ();

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteNameSpace

(JNIEnv *jEnv, jobject jThs, jint jCc, jstring jNs) {

CIMClient *cCc=(CIMClient*)jCc;

const char* str=jEnv->GetStringUTFChars(jNs,NULL);

// -------------------------------------

String ns(str);

// ---

jEnv->ReleaseStringUTFChars(jNs,str);

// - SelectExp

String lastNsComp;

// ---

String nsBase;

// -------------------------------------

normalizeNs(ns,nsBase,lastNsComp);

* Class: org_pegasus_jmpi_SelectExp

* Method: _finalize

* Signature: (I)V

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_SelectExp__1finalize

(JNIEnv *jEnv, jobject jThs, jlong jWQLStmt)

{

WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (

jlong,

WQLSelectStatement*,

jWQLStmt);

CIMObjectPath cop(String::EMPTY,CIMNamespaceName(nsBase),CIMName("__Namespace"));

delete wql_stmt;

Array<CIMKeyBinding> kb;

kb.append(CIMKeyBinding(("Name"),CIMValue(lastNsComp)));

cop.setKeyBindings(kb);

try {

DEBUG_ConvertCleanup (jlong, jWQLStmt);

cCc->deleteInstance(CIMNamespaceName(nsBase),cop);

}

Catch(jEnv);

return;

}

} // extern "C"

* Class: org_pegasus_jmpi_SelectExp

* Method: _newSelectExp

* Signature: (Ljava/lang/String;)I

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_SelectExp__1newSelectExp

(JNIEnv *jEnv, jobject jThs, jstring jQuery)

{

const char *pszQuery = jEnv->GetStringUTFChars (jQuery, NULL);

WQLSelectStatement *wql_stmt = NULL;

String queryLanguage (CALL_SIGN_WQL);

String query (pszQuery);

wql_stmt = new WQLSelectStatement (queryLanguage, query);

PEG_TRACE((TRC_PROVIDERMANAGER,Tracer::LEVEL4,

"Java_org_pegasus_jmpi_SelectExp__1newSelectExp: wql_stmt = %p",

wql_stmt));

PEGASUS_NAMESPACE_END

try

{

WQLParser::parse (query, *wql_stmt);

}

catch (const Exception &e)

{

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 *, jlong, wql_stmt);

}

* Class: org_pegasus_jmpi_SelectExp

* Method: _getSelectString

* Signature: (I)Ljava/lang/String;

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_SelectExp__1getSelectString

(JNIEnv *jEnv, jobject jThs, jlong jWQLStmt)

{

WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC(

jlong,

WQLSelectStatement*,

jWQLStmt);

String cond;

if (wql_stmt)

{

try

{

cond = wql_stmt->getQuery ();

}

catch (const Exception &e)

{

cerr << "Java_org_pegasus_jmpi_SelectExp__1getSelectString: Caught: "

<< e.getMessage () << endl;

cond = "";

}

else

{

cond = "";

}

return (jstring)jEnv->NewStringUTF (cond.getCString ());

}

} // extern "C"

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.14
changed lines
	Added in v.1.80

No CVS admin address has been configured