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.3 and 1.35.2.2

version 1.3, 2004/06/28 16:56:08

version 1.35.2.2, 2006/05/17 20:57:39

Line 1

//%2003////////////////////////////////////////////////////////////////////////

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

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

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

// IBM Corp.; EMC Corporation, The Open Group.

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

Line 34

// Modified By: Adrian Dutta

// Andy Viciu

// Magda Vacarelu

// David Dillard, VERITAS Software Corp.

// (david.dillard@veritas.com)

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

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

#include "JMPIImpl.h"

#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)

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

Line 57

#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/Provider/CIMOMHandle.h>

#include <Pegasus/Client/CIMClient.h>

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

#include <Pegasus/ProviderManager2/CMPI/CMPI_SelectExp.h>

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

Line 56

Line 70

JvmVector JMPIjvm::jv;

int JMPIjvm::trace=0;

typedef struct {

#ifdef PEGASUS_DEBUG

int clsIndex;

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

const char * methodName;

#else

const char * signature;

#define DDD(x)

} METHOD_STRUCT;

#endif

#include "Convert.h"

JMPIjvm::ClassTable JMPIjvm::_classTable;

JMPIjvm::ObjectTable JMPIjvm::_objectTable;

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

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

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

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

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

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

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

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

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

};

const METHOD_STRUCT instanceMethodNames[]={

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/*40 CIMArgumentNewI */ { /*CIMArgument */29, "<init>", "(I)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 CIMValueNewI */ { /*CIMValue */19, "<init>", "(I)V" },

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

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

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

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

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

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

};

const METHOD_STRUCT staticMethodNames[]={

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

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

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

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

};

static int methodInitDone=0;

jclass classRefs[sizeof(classNames)/sizeof(char*)];

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

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

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

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

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

static jclass providerClassRef;

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

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

{

jclass localRefCls=env->FindClass(name);

// if (env->ExceptionOccurred())

// env->ExceptionDescribe();

if (localRefCls==NULL)

if (localRefCls==NULL) return JNI_FALSE;

return JNI_FALSE;

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

#if 0

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

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

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

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

env->ReleaseStringUTFChars (jstringResult, pszResult);

#else

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

#endif

env->DeleteLocalRef(localRefCls);

return globalRefCls;

}

JMPIjvm::JMPIjvm() {

JMPIjvm::JMPIjvm()

{

initJVM();

}

JMPIjvm::~JMPIjvm() {

JMPIjvm::~JMPIjvm()

{

}

int JMPIjvm::cacheIDs(JNIEnv *env) {

int JMPIjvm::cacheIDs(JNIEnv *env)

if (methodInitDone==1) return JNI_TRUE;

{

if (methodInitDone==-1) return JNI_FALSE;

if (methodInitDone==1)

return JNI_TRUE;

if (methodInitDone==-1)

return JNI_FALSE;

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

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;

//////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<classNames[i]<<PEGASUS_STD(endl));

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

{

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

return JNI_FALSE;

}

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

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

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

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

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

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

classRefs[instanceMethodNames[j].clsIndex],

instanceMethodNames[j].methodName,

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

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

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

{

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

return 0;

}

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

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

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

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

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

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

classRefs[staticMethodNames[k].clsIndex],

staticMethodNames[k].methodName,

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

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

{

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

return 0;

}

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

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

jv.env=env;

jv.classRefs=classRefs;

jv.instMethodIDs=instanceMethodIDs;

jv.staticMethodIDs=staticMethodIDs;

jv.instanceMethodNames=instanceMethodNames;

methodInitDone=1;

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 (trace) cerr<<"--- JPIjvm::destroyJVM()\n";

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

#ifdef JAVA_DESTROY_VM_WORKS

if (jvm!=NULL) {

JvmVector *jv;

attachThread(&jv);

jvm->DestroyJavaVM();

jvm=NULL;

return 0;

}

#endif

return -1;

}

Mutex JMPIjvm::_initMutex;

int JMPIjvm::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;

#ifdef PEGASUS_DEBUG

if (getenv("PEGASUS_JMPI_TRACE")) JMPIjvm::trace=1;

else JMPIjvm::trace=0;

#else

JMPIjvm::trace=0;

#endif

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

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

else trace=0;

if (trace) cerr<<"--- JPIjvm::initJVM()\n";

jv.initRc=0;

envcp=getenv("CLASSPATH");

envstring=getenv("CLASSPATH");

if (envcp==NULL) {

if (envstring==NULL) {

jv.initRc=1;

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

return -1;

}

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

///maxoption++;

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

{

JVMOPTIONS *pEnvOption = &aEnvOptions[i];

envstring = getenv (pEnvOption->pszEnvName);

if (envstring)

{

if (pEnvOption->fSplit)

{

bool fCommaFound = true;

string stringValues = envstring;

string::size_type posStart = 0;

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

while (fCommaFound)

{

string stringValue;

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

if (posComma != string::npos)

{

fCommaFound = true;

stringValue = stringValues.substr (posStart, posComma);

posStart = posComma + 1;

}

else

{

fCommaFound = false;

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

}

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

maxoption++;

oss.str ("");

oss << pEnvOption->pszPrefix << stringValue;

JNIoptions.append (oss.str ());

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

}

else

{

maxoption++;

oss.str ("");

oss << pEnvOption->pszPrefix << envstring;

JNIoptions.append (oss.str ());

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

}

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

if (!poptions)

{

jv.initRc=1;

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

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

return -1;

}

strcat(classpath,envcp);

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

options[0].optionString=classpath;

{

vm_args.version=0x00010002;

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

vm_args.options=options;

vm_args.nOptions=1;

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

}

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 (res!=0) {

fprintf(stderr,"Can not create Java VM\n");

if (poptions)

exit(1);

{

free (poptions);

}

jv.jvm=jvm;

jv.env=env;

if (cacheIDs(env)==1) {

if (res!=0) {

jv.classRefs=classRefs;

jv.initRc=1;

jv.instMethodIDs=instanceMethodIDs;

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

return -1;

}

cacheIDs(env);

if (env->ExceptionOccurred()) {

jv.initRc=1;

env->ExceptionDescribe();

exit(1);

#ifdef JAVA_DESTROY_VM_WORKS

JvmVector *jv = NULL;

attachThread (&jv);

jvm->DestroyJavaVM ();

jvm = NULL;

#endif

return -1;

}

jv.initRc=1;

jv.jvm=jvm;

return res;

}

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

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

JNIEnv* env;

{

if (jvm==NULL) initJVM();

JNIEnv* env = NULL;

if (jvm == NULL)

{

initJVM ();

if (jvm == NULL)

return NULL;

}

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

*jvp=&jv;

return env;

}

void JMPIjvm::detachThread() {

void JMPIjvm::detachThread()

{

jvm->DetachCurrentThread();

}

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

const char *cn, jclass *cls)

{

static jobject gProv=NULL;

jobject gProv=NULL;

static jclass scls=NULL;

jclass scls=NULL;

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

_objectTable.lookup(cln,gProv);

_classTable.lookup(cln,scls);

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

if (gProv) {

*cls=scls;

return gProv;

}

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

DDD(PEGASUS_STD(cout)<<"--- jar: "<<jar<<PEGASUS_STD(endl));

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

DDD(PEGASUS_STD(cout)<<"--- cln: "<<cln<<PEGASUS_STD(endl));

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

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

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

jclass jcls=(jclass)env->CallStaticObjectMethod(JMPIjvm::jv.JarClassLoaderRef,jv.JarClassLoaderLoad,

jjar,jcln);

if (env->ExceptionCheck()) {

env->ExceptionDescribe();

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

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

// return NULL;

////////return NULL;

}

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

if (env->ExceptionCheck()) {

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

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

DDD(env->ExceptionDescribe());

return NULL;

}

*cls=scls;

if (scls)

{

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

_classTable.insert(cln,scls);

}

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

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

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

if (env->ExceptionCheck()) {

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

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

return NULL;

}

if (gProv)

{

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

_objectTable.insert(cln,gProv);

}

return gProv;

}

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

{

static jobject gProv=NULL;

String cln = cn;

static jclass scls=NULL;

jobject gProv=NULL;

jclass scls=NULL;

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

_objectTable.lookup(cln,gProv);

_classTable.lookup(cln,scls);

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

if (gProv) {

*cls=scls;

return gProv;

Line 330

Line 588

scls=getGlobalClassRef(env,cn);

if (env->ExceptionCheck()) {

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

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

DDD(env->ExceptionDescribe());

return NULL;

}

*cls=scls;

if (scls)

{

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

_classTable.insert(cln,scls);

}

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

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

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

if (env->ExceptionCheck()) {

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

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

return NULL;

}

if (gProv)

{

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

_objectTable.insert(cln,gProv);

}

return gProv;

}

void JMPIjvm::checkException(JNIEnv *env)

{

jstring msg=NULL,id=NULL;

if (env->ExceptionCheck()) {

jstring jMsg=NULL,jId=NULL;

int code;

const char *cp;

char hcp[512]="",hcp1[128];

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

String m=String::EMPTY;

if (env->ExceptionCheck()) {

jthrowable err=env->ExceptionOccurred();

if (trace)

DDD(env->ExceptionDescribe());

env->ExceptionDescribe();

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

env->ExceptionClear();

if (err) {

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

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

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

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

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

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

if (id) {

if (jId) {

const char *cp=env->GetStringUTFChars(id,NULL);

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

strncpy(hcp1,cp,511);

id=String(cp);

env->ReleaseStringUTFChars(id,cp);

env->ReleaseStringUTFChars(jId,cp);

}

if (msg) {

if (jMsg) {

const char *cp=env->GetStringUTFChars(msg,NULL);

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

strncpy(hcp,cp,511);

msg=String(cp);

env->ReleaseStringUTFChars(msg,cp);

env->ReleaseStringUTFChars(jMsg,cp);

m=String(hcp);

}

if (trace)

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

cerr<<"--- throwing Pegasus exception: "<<hcp1<<" ("<<hcp<<") "<<endl;

throw CIMException((CIMStatusCode)code,m);

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

}

else {

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

env->ExceptionDescribe();

exit(13);

}

Line 441

Line 719

CIMPropertyList getList(JNIEnv *jEnv, jobjectArray l) {

CIMPropertyList pl;

if (l) {

Array<CIMName> n;

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

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

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

n.append(pn);

jEnv->ReleaseStringUTFChars(jObj,pn);

}

pl.set(n);

}

return pl;

}

extern "C" {

Line 448

Line 747

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

JMPIjvm::cacheIDs(jEnv);

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

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

jEnv->Throw((jthrowable)ev);

}

void throwFailedException(JNIEnv *jEnv) {

JMPIjvm::cacheIDs(jEnv);

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

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

jEnv->Throw((jthrowable)ev);

}

void throwNotSupportedException(JNIEnv *jEnv) {

JMPIjvm::cacheIDs(jEnv);

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

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

jEnv->Throw((jthrowable)ev);

}

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

// ---

// - CIMException

// ---

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

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1new

(JNIEnv *jEnv, jobject jThs) {

JMPIjvm::cacheIDs(jEnv);

jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNew);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newS

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

JMPIjvm::cacheIDs(jEnv);

jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewSt,jM);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSO

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

JMPIjvm::cacheIDs(jEnv);

jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewStOb,jM,jO1);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSOO

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

JMPIjvm::cacheIDs(jEnv);

jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewStObOb,jM,jO1,jO2);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSOOO

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

JMPIjvm::cacheIDs(jEnv);

jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewStObObOb,jM,jO1,jO2,jO3);

}

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

// ---

// - CIMOMHandle

Line 472

Line 811

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getClass

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

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

jboolean iq, jboolean ic, jobjectArray jPl)

CIMObjectPath *cop=(CIMObjectPath*)jCop;

{

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

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

CIMPropertyList pl;

OperationContext ctx;

if (jPl)

pl=getList(jEnv,jPl);

else

pl=CIMPropertyList();

try {

CIMClass cc=ch->getClass(ctx,cop->getNameSpace(),cop->getClassName(),

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

cop->getClassName(),

(Boolean)lo,

true,true,CIMPropertyList());

(Boolean)iq,

return (jint)new CIMClass(cc);

(Boolean)ic,

pl);

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

}

Catch(jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumClass

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createClass

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

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

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

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

OperationContext ctx;

try {

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

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

true,(Boolean)lo,true,true);

if (!cop->getClassName().isNull())

en.append(ch->getClass(ctx,cop->getNameSpace(),cop->getClassName(),(Boolean)lo,

true,true,CIMPropertyList()));

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

CIMClass *cls=new CIMClass(en[i]);

jobject jCls=jEnv->NewObject(classRefs[17],instanceMethodIDs[19],(jint)cls);

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

}

return;

}

Catch(jEnv);

return;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getProperty

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setClass

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

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

{

CIMOMHandle *ch=(CIMOMHandle*)jCh;

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

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

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

OperationContext ctx;

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

try {

CIMName prop(str);

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

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

jEnv->ReleaseStringUTFChars(jN,str);

return (jint)(void*)cv;

}

Catch(jEnv);

return -1;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteClass

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

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

{

CIMOMHandle *ch=(CIMOMHandle*)jCh;

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

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

OperationContext ctx;

try {

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

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

}

Catch(jEnv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumInstances

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClassNames

(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean jDeep, jboolean jLocalOnly, jobject jVec) {

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

{

CIMOMHandle *ch=(CIMOMHandle*)jCh;

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

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

CIMNamespaceName ns = cop->getNameSpace();

OperationContext ctx;

try {

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

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

(Boolean)jDeep,(Boolean)jLocalOnly,true,true,CIMPropertyList());

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

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

CIMInstance *ci=new CIMInstance(inst[i]);

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

jobject jCi=jEnv->NewObject(classRefs[18],instanceMethodIDs[20],(jint)ci);

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

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

}

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

}

Catch(jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getInstance

return 0;

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

}

CIMOMHandle *ch=(CIMOMHandle*)jCh;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClasses

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

jboolean lo, jboolean iq, jboolean ic)

{

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

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

OperationContext ctx;

try {

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

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

(Boolean)jLocalOnly,false,false,CIMPropertyList()));

cop->getNameSpace(),

return (jint)(void*)inst;

cop->getClassName(),

(Boolean)deep,

(Boolean)lo,

(Boolean)iq,

(Boolean)ic);

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

}

Catch(jEnv);

return -1;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

return 0;

CIMInstance *ind=(CIMInstance*)jInd;

}

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getInstance

String name(str);

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

jEnv->ReleaseStringUTFChars(jName,str);

jobjectArray jPl)

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

{

String ns(str);

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

jEnv->ReleaseStringUTFChars(jNs,str);

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

OperationContext ctx;

CIMPropertyList pl;

JMPIProviderManager::indProvRecord *prec;

if (jPl)

OperationContext* context;

pl=getList(jEnv,jPl);

else

pl=CIMPropertyList();

if (JMPIProviderManager::provTab.lookup(name,prec)) {

if (prec->enabled) {

context=prec->ctx;

try {

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

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

cop->getNameSpace(),

*cop,

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,

pl));

return DEBUG_ConvertCToJava (CIMInstance*, jint, inst);

}

Catch(jEnv);

}

else {

cout<<"_deliverEvent() "<<name<<" not found"<<endl;

}

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

return -1;

// ---

}

// - CIMClass

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1newInstance

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance

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

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

CIMClass *cls=(CIMClass*)jCls;

{

// Array<Sint8> ar;

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

// cls->toXml(ar);

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

// cout<<"--- class: "<<ar.getData()<<endl;

OperationContext ctx;

try {

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

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

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

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

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

CIMProperty cp= cls->getProperty(i);

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

// CIMProperty(cp.getName(), cp.getValue(), cp.getArraySize(),

// cp.getReferenceClassName(), cp.getClassOrigin()));

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

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

}

return (jint)ci;

}

Catch(jEnv);

return 0;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getName

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createInstance

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

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

CIMClass *cls=(CIMClass*)jCls;

{

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

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

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

OperationContext ctx;

try {

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

ci->setPath(*cop);

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

return str;

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

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

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifier

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1modifyInstance

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

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

CIMClass *cls=(CIMClass*)jCls;

jboolean iq, jobjectArray jPl)

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

{

jint rv=-1;

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

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

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

if (pos!=PEG_NOT_FOUND)

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

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

CIMPropertyList pl = getList(jEnv,jPl);

jEnv->ReleaseStringUTFChars(jN,str);

OperationContext ctx;

return rv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperty

try {

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

ci->setPath(*cop);

CIMClass *cls=(CIMClass*)jCls;

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

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;

}

Catch(jEnv);

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1hasQualifier

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

CIMClass *cls=(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 jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstanceNames

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

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

CIMClass *cls=(CIMClass*)jCls;

{

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

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

OperationContext ctx;

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

try {

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

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

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

cop->getNameSpace(),

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

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

}

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

return jVec;

}

Catch(jEnv);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1new

return 0;

(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 (jint)(void*)cls;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getSuperClass

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstances

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

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

CIMClass *cls =(CIMClass *)jCls;

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

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

{

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

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

return str;

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

}

CIMPropertyList pl;

OperationContext ctx;

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getKeys

if (jPl)

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

pl=getList(jEnv,jPl);

CIMClass *cls=(CIMClass*)jCls;

else

if (cls->hasKeys()) {

pl=CIMPropertyList();

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

try {

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

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

CIMClass *cls=(CIMClass*)jCls;

cop->getNameSpace(),

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

cop->getClassName(),

jint rv=-1;

(Boolean)deep,

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

(Boolean)lo,

if (pos!=PEG_NOT_FOUND) {

(Boolean)iq,

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

(Boolean)ic,

}

pl);

jEnv->ReleaseStringUTFChars(jN,str);

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

return rv;

}

Catch(jEnv);

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1equals

return 0;

(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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1execQuery

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

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

CIMClass *cls=(CIMClass*)jCls;

{

delete cls;

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

}

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

OperationContext ctx;

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

String query(str);

jEnv->ReleaseStringUTFChars(jQuery,str);

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

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

String ql(str);

// ---

// - CIMInstance

// ---

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

jEnv->ReleaseStringUTFChars(jQl,str);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1new

(JNIEnv *jEnv, jobject jThs) {

try {

return (jint)new CIMInstance();

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

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1newCn

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

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

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

return (jint)new CIMInstance(CIMName(str));

}

Catch(jEnv);

//Added by Andy Viciu

return 0;

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setName

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

CIMInstance *ci=(CIMInstance*)jInst;

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

/* NOT SUPPORTED AND NOT NEEDED*/

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperty

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

CIMInstance *ci=(CIMInstance*)jInst;

CIMValue *cv=(CIMValue*)jV;

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

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

if (pos!=PEG_NOT_FOUND) {

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getProperty

CIMProperty cp=ci->getProperty(pos);

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

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

{

cp.setValue(*cv);

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

else {

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

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

OperationContext ctx;

cerr<<"!!! CIMInstance.setProperty - Wrong type of CIMValue (instance name:"<<ci->getClassName().getString()<<", property name: "<<str<<")";

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

}

CIMName prop(str);

}

else {

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

ci->addProperty(*cp);

//throw CIMException(CIM_ERR_FAILED, String(str).append(String(" - Property not found")));

}

jEnv->ReleaseStringUTFChars(jN,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));

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

if (pos!=PEG_NOT_FOUND) {

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

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

rv=(jint)cp;

}

Catch(jEnv);

jEnv->ReleaseStringUTFChars(jN,str);

return rv;

return -1;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getKeyValuePairs

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setProperty

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

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

CIMInstance *ci=(CIMInstance*)jInst;

{

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

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

OperationContext ctx;

CIMValue *val = (CIMValue*)jCop;

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

CIMName pName(str);

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

jEnv->ReleaseStringUTFChars(jPn,str);

if (ci->getProperty(i).findQualifier(String("key"))!=PEG_NOT_FOUND) {

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

try {

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

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

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

}

Catch(jEnv);

}

return jVec;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod

}

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

{

JMPIjvm::cacheIDs(jEnv);

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMInstance__1getClassName

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

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

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, 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) {

JMPIjvm::checkException(jEnv);

CIMInstance *ci=(CIMInstance*)jInst;

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;

}

JMPIjvm::checkException(jEnv);

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

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

// ---

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

// - CIMObjectPath

// ---

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

CIMObjectPath* construct() {

JMPIjvm::checkException(jEnv);

CIMObjectPath *cop=new CIMObjectPath();

_nameSpace n;

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

cop->setNameSpace(n.nameSpace());

cop->setHost(n.hostName());

return cop;

}

try {

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1new

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

(JNIEnv *jEnv, jobject jThs) {

const CIMParamValue &parm = out[i];

return (jint)construct();

const CIMValue v = parm.getValue();

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

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

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

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

}

return DEBUG_ConvertCToJava (CIMValue*, jint, val);

}

Catch(jEnv);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCn

return 0;

(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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod24

(JNIEnv *jEnv, jobject jThs, jstring jCn, jstring jNs) {

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

CIMObjectPath *cop=construct();

jobjectArray jIn, jobjectArray jOut)

{

JMPIjvm::cacheIDs(jEnv);

const char *str1=jEnv->GetStringUTFChars(jCn,NULL);

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

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

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

try {

OperationContext ctx;

if (str1) cop->setClassName(str1);

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

if (str2) cop->setNameSpace(str2);

CIMName method(str);

}

catch (Exception e) {

jobject ev=jEnv->NewObject(classRefs[13],instanceMethodIDs[33],(jint)1,jEnv->NewStringUTF(e.getMessage().getCString()));

jEnv->Throw((jthrowable)ev);

}

jEnv->ReleaseStringUTFChars(jCn,str1);

jEnv->ReleaseStringUTFChars(jMn,str);

jEnv->ReleaseStringUTFChars(jNs,str2);

return (jint)(void*)cop;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1_newCi

Array<CIMParamValue> in;

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

Array<CIMParamValue> out;

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

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

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

JMPIjvm::checkException(jEnv);

CIMObjectPath *cop=(CIMObjectPath*)jCop;

delete cop;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getHost

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

(JNIEnv *jEnv, jobject jThs, jint jOp) {

JMPIjvm::checkException(jEnv);

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

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

(JNIEnv *jEnv, jobject jThs, jint jOp, jstring jName) {

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

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

JMPIjvm::checkException(jEnv);

(JNIEnv *jEnv, jobject jThs, jint jOp) {

CIMObjectPath *cop=(CIMObjectPath*)jOp;

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

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

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setObjectName

in.append(*p);

(JNIEnv *jEnv, jobject jThs, jint jOp, jstring jName) {

CIMObjectPath *cop=(CIMObjectPath*)jOp;

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

cop->setClassName(String(str));

jEnv->ReleaseStringUTFChars(jName,str);

}

try {

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

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getNameSpace

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

(JNIEnv *jEnv, jobject jThs, jint jOp) {

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

CIMObjectPath *cop=(CIMObjectPath*)jOp;

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

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

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

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setNameSpace

jEnv->SetObjectArrayElement(jOut,i,

(JNIEnv *jEnv, jobject jThs, jint jOp, jstring jName) {

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

CIMObjectPath *cop=(CIMObjectPath*)jOp;

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

cop->setNameSpace(CIMNamespaceName(str));

jEnv->ReleaseStringUTFChars(jName,str);

}

return DEBUG_ConvertCToJava (CIMValue*, jint, val);

}

Catch(jEnv);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1addKey

return 0;

(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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associatorNames

(JNIEnv *jEnv, jobject jThs, jint jOp, jobject jVec) {

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

CIMObjectPath *cop=(CIMObjectPath*)jOp;

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

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

{

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

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

OperationContext ctx;

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

CIMName assocClass(str);

for (Uint32 i=0,s=akb.size(); i<s; i++) {

jEnv->ReleaseStringUTFChars(jAssocClass,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;

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

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

CIMName resultClass(str);

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

}

return jVec;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeyValue

jEnv->ReleaseStringUTFChars(jResultClass,str);

(JNIEnv *jEnv, jobject jThs, jint jOp, jstring jStr) {

CIMObjectPath *cop=(CIMObjectPath*)jOp;

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 jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1set

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

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

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setKeys

String role(str);

(JNIEnv *jEnv, jobject jThs, jint jOp, jobject jVec) {

CIMObjectPath *cop=(CIMObjectPath*)jOp;

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

CIMProperty *cp=(CIMProperty*)jEnv->CallIntMethod(o,JMPIjvm::jv.PropertyCInst);

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

}

cop->setKeyBindings(akb);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1clone

jEnv->ReleaseStringUTFChars(jRole,str);

(JNIEnv *jEnv, jobject jThs, jint jOp) {

CIMObjectPath *cop=(CIMObjectPath*)jOp;

CIMObjectPath *copl=new CIMObjectPath(cop->getHost(), cop->getNameSpace(), cop->getClassName(), cop->getKeyBindings());

return (jint)(void*)copl;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1toString

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

(JNIEnv *jEnv, jobject jThs, jint jOp) {

CIMObjectPath *cop=(CIMObjectPath*)jOp;

const String &ns=cop->toString();

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

return str;

}

String resultRole(str);

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

jEnv->ReleaseStringUTFChars(jResultRole,str);

// ---

// - CIMDataType

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1new

try {

(JNIEnv *jEnv, jobject jThs, jint type) {

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

return (jint)(void*) new _dataType(type);

cop->getNameSpace(),

}

*cop,

assocClass,

resultClass,

role,

resultRole);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newAr

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

(JNIEnv *jEnv, jobject jThs, jint type, jint size) {

return (jint)(void*) new _dataType(type,size);

}

Catch(jEnv);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newRef

return 0;

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

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

jint cInst=(jint)(void*)new _dataType(type,String(ref));

jEnv->ReleaseStringUTFChars(jRef,ref);

return cInst;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isArray

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associators

(JNIEnv *jEnv, jobject jThs, jint jDt) {

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

_dataType *dt=(_dataType*)jDt;

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

return dt->_array==true;

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)

}

{

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

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

OperationContext ctx;

CIMPropertyList pl = getList(jEnv,jPl);

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

CIMName assocClass(str);

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isreference

jEnv->ReleaseStringUTFChars(jAssocClass,str);

(JNIEnv *jEnv, jobject jThs, jint jDt) {

_dataType *dt=(_dataType*)jDt;

return dt->_reference==true;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isReference

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

(JNIEnv *jEnv, jobject jThs, jint jDt) {

_dataType *dt=(_dataType*)jDt;

return dt->_reference==true;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getType

CIMName resultClass(str);

(JNIEnv *jEnv, jobject jThs, jint jDt) {

_dataType *dt=(_dataType*)jDt;

return dt->_type;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getSize

jEnv->ReleaseStringUTFChars(jResultClass,str);

(JNIEnv *jEnv, jobject jThs, jint jDt) {

_dataType *dt=(_dataType*)jDt;

return dt->_size;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1getRefClassName

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

(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

String role(str);

(JNIEnv *jEnv, jobject jThs, jint jDt) {

_dataType *dt=(_dataType*)jDt;

jstring str=NULL;

if (dt->_type & 0x10) {

char tmp[32];

strcpy(tmp,jTypeToChars[dt->_type-0x10]);

strcat(tmp,"[]");

str=jEnv->NewStringUTF(tmp);

}

else if (dt->_type & 0x20) {

String tmp=dt->_refClass+" REF";

str=jEnv->NewStringUTF(tmp.getCString());

}

else {

str=jEnv->NewStringUTF(jTypeToChars[dt->_type]);

}

return str;

}

jEnv->ReleaseStringUTFChars(jRole,str);

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

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

String resultRole(str);

// ---

// - CIMProperty

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getValue

jEnv->ReleaseStringUTFChars(jResultRole,str);

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

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

try {

CIMValue *cv=(CIMValue*)jV;

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

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

cop->getNameSpace(),

CIMProperty *cp;

*cop,

assocClass,

resultClass,

role,

resultRole,

(Boolean)includeQualifiers,

(Boolean)includeClassOrigin,

pl);

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

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

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

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

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

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

}

jEnv->ReleaseStringUTFChars(jN,str);

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

return (jint)cp;

}

Catch(jEnv);

return -1;

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setValue

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1referenceNames

(JNIEnv *jEnv, jobject jThs, jint jP,jint jV) {

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

CIMProperty *cp=(CIMProperty*)jP;

jstring jAssocClass, jstring jRole)

CIMValue *cv=(CIMValue*)jV;

{

cp->setValue(*cv);

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

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

OperationContext ctx;

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

CIMName assocClass(str);

jEnv->ReleaseStringUTFChars(jAssocClass,str);

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

String role(str);

jEnv->ReleaseStringUTFChars(jRole,str);

try {

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

cop->getNameSpace(),

*cop,

assocClass,

role);

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

}

Catch(jEnv);

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isArray

return 0;

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

CIMProperty *cp=(CIMProperty*)jP;

return (jboolean)cp->isArray();

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addValue

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1references

(JNIEnv *jEnv, jobject jThs, jint jP, jint jV) {

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

CIMProperty *cp=(CIMProperty*)jP;

jstring jAssocClass, jstring jRole,

CIMValue *cvin=(CIMValue*)jV;

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)

CIMValue cv=cp->getValue();

{

if (cvin->isNull())

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

throwCIMException(jEnv,"+++ null cvin value ");

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

if (!cv.isArray())

OperationContext ctx;

throwCIMException(jEnv,"+++ not an array ");

CIMPropertyList pl = getList(jEnv,jPl);

if (cvin->getType()!=cv.getType())

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

throwCIMException(jEnv,"+++ type mismatch ");

CIMName assocClass(str);

CIMType type=cv.getType();

switch (type) {

case CIMTYPE_BOOLEAN: {

Boolean bo;

cvin->get(bo);

Array<Boolean> boarr;

cv.get(boarr);

boarr.append(bo);

}

break;

case CIMTYPE_UINT8: {

Uint8 u8;

cvin->get(u8);

Array<Uint8> u8arr;

cv.get(u8arr);

u8arr.append(u8);

}

break;

case CIMTYPE_SINT8: {

Sint8 s8;

cvin->get(s8);

Array<Sint8> s8arr;

cv.get(s8arr);

s8arr.append(s8);

}

break;

case CIMTYPE_UINT16: {

Uint16 u16;

cvin->get(u16);

Array<Uint16> u16arr;

cv.get(u16arr);

u16arr.append(u16);

}

break;

case CIMTYPE_SINT16: {

Sint16 s16;

cvin->get(s16);

Array<Sint16> s16arr;

cv.get(s16arr);

s16arr.append(s16);

}

break;

case CIMTYPE_UINT32: {

Uint32 u32;

cvin->get(u32);

Array<Uint32> u32arr;

cv.get(u32arr);

u32arr.append(u32);

}

break;

case CIMTYPE_SINT32: {

Sint32 s32;

cvin->get(s32);

Array<Sint32> s32arr;

cv.get(s32arr);

s32arr.append(s32);

}

break;

case CIMTYPE_UINT64: {

Uint64 u64;

cvin->get(u64);

Array<Uint64> u64arr;

cv.get(u64arr);

u64arr.append(u64);

}

break;

case CIMTYPE_SINT64: {

Sint64 s64;

cvin->get(s64);

Array<Sint64> s64arr;

cv.get(s64arr);

s64arr.append(s64);

}

break;

case CIMTYPE_REAL32: {

Real32 f;

cvin->get(f);

Array<Real32> farr;

cv.get(farr);

farr.append(f);

}

break;

case CIMTYPE_REAL64: {

Real64 d;

cvin->get(d);

Array<Real64> darr;

cv.get(darr);

darr.append(d);

}

break;

case CIMTYPE_STRING: {

String str;

cvin->get(str);

Array<String> strarr;

cv.get(strarr);

strarr.append(str);

}

break;

case CIMTYPE_REFERENCE: {

CIMObjectPath ref;

cvin->get(ref);

Array<CIMObjectPath> refarr;

cv.get(refarr);

refarr.append(ref);

}

break;

default:

throwCIMException(jEnv,"+++ unsupported type ");

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getName

jEnv->ReleaseStringUTFChars(jAssocClass,str);

(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 jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isReference

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

(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

String role(str);

(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

jEnv->ReleaseStringUTFChars(jRole,str);

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

CIMProperty *cp=(CIMProperty*)jP;

try {

String ref=cp->getReferenceClassName().getString();

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

_dataType *type=new _dataType(pTypeToJType[cp->getType()],

cop->getNameSpace(),

cp->getArraySize(),

*cop,

ref.size() ? true : false,

assocClass,

false,

role,

cp->isArray(),

(Boolean)includeQualifiers,

ref,

(Boolean)includeClassOrigin,

true);

pl);

return (jint)type;

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

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

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

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMProperty__1getIdentifier

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

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

CIMProperty *cp=(CIMProperty*)jP;

const String &n=cp->getName().getString();

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

return str;

}

Catch(jEnv);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1finalize

return 0;

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

CIMProperty *cp=(CIMProperty*)jP;

delete cp;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent

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

{

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

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

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

String name (str);

jEnv->ReleaseStringUTFChars (jName, str);

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

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

// ---

// - CIMQualifier

// ---

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

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1finalize

String ns (str);

(JNIEnv *jEnv, jobject jThs, jint jQ) {

CIMQualifier *cq=(CIMQualifier*)jQ;

delete cq;

}

jEnv->ReleaseStringUTFChars (jNs, str);

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

CIMObjectPath ref (ind->getPath ());

// ---

// - CIMDateTime

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetime

ref.setNameSpace (ns);

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

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

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

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

CIMDateTime *dt;

ind->setPath (ref);

if (strlen(str)==0)

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

dt=new CIMDateTime();

else

JMPIProviderManager::indProvRecord *prec = NULL;

dt=new CIMDateTime(String(str));

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

jEnv->ReleaseStringUTFChars(jN,str);

OperationContext *context = NULL;

return (jint)dt;

bool fResult = false;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetimeempty

{

(JNIEnv *jEnv, jobject jThs) {

AutoMutex lock (JMPIProviderManager::mutexProvTab);

CIMDateTime *dt=new CIMDateTime(CIMDateTime::getCurrentDateTime ());

return (jint)dt;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1after

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

(JNIEnv *jEnv, jobject jThs, jint jC, jint jD) {

CIMDateTime *ct = (CIMDateTime *) jC;

CIMDateTime *dt = (CIMDateTime *) jD;

return (jboolean)(ct->getDifference(*ct, *dt)>0);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDateTime__1finalize

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

(JNIEnv *jEnv, jobject jThs, jint jDT) {

CIMDateTime *cdt = (CIMDateTime *) jDT;

delete cdt;

}

if (fResult)

{

if (prec->enabled)

{

try

{

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

}

Catch(jEnv);

}

else

{

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

}

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

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1finalize

// ---

(JNIEnv *jEnv, jobject jThs, jint jCh)

// - CIMMethod

{

// ---

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

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1getType

delete ch;

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

CIMMethod *cm=(CIMMethod*)jM;

return (jint)cm->getType();

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize

DEBUG_ConvertCleanup (jint, jCh);

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

CIMMethod *cm=(CIMMethod*)jM;

delete cm;

}

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

// ---

// - CIMValue

// - CIMClass

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1newInstance

(JNIEnv *jEnv, jobject jThs, jint jCls)

{

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byte

try {

(JNIEnv *jEnv, jobject jThs, jbyte jb, jboolean notSigned) {

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

CIMValue *cv=NULL;

if (notSigned) cv=new CIMValue((Uint8)jb);

else cv=new CIMValue((Sint8)jb);

return (jint)cv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1short

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

(JNIEnv *jEnv, jobject jThs, jshort js, jboolean notSigned) {

try {

CIMValue *cv=NULL;

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

if (notSigned) cv=new CIMValue((Uint16)js);

else cv=new CIMValue((Sint16)js);

return (jint)cv;

}

catch (Exception e) {}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue_makeInt

(JNIEnv *jEnv, jobject jThs, jlong ji, jboolean notSigned) {

CIMValue *cv=NULL;

if (notSigned) cv=new CIMValue((Uint32)ji);

else cv=new CIMValue((Sint32)ji);

return (jint)cv;

}

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

CIMProperty cp = cls->getProperty(i);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1long

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

(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

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

(JNIEnv *jEnv, jobject jThs, jfloat jF) {

try {

CIMValue *cv=new CIMValue(jF);

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

return (jint)cv;

}

catch (Exception e) {}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1double

(JNIEnv *jEnv, jobject jThs, jdouble jD) {

CIMValue *cv=new CIMValue(jD);

return (jint)cv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1string

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

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1ref

return DEBUG_ConvertCToJava (CIMInstance*, jint, ci);

(JNIEnv *jEnv, jobject jThs, jint jR) {

CIMObjectPath *ref=(CIMObjectPath*)jR;

CIMValue *cv=new CIMValue(*ref);

return (jint)cv;

}

Catch(jEnv);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1datetime

return 0;

(JNIEnv *jEnv, jobject jThs, jint jDT) {

CIMDateTime *dt=(CIMDateTime*)jDT;

CIMValue *cv=new CIMValue(*dt);

return (jint)cv;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMValue__1isArray

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getName

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

(JNIEnv *jEnv, jobject jThs, jint jCls)

CIMValue *cv=(CIMValue*)jP;

{

return (jboolean)cv->isArray();

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

try {

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

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

return str;

}

Catch(jEnv);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1boolean

return 0;

(JNIEnv *jEnv, jobject jThs, jboolean jB) {

CIMValue *cv=new CIMValue((Boolean)jB);

return (jint)cv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byteArray

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifier

(JNIEnv *jEnv, jobject jThs, jshortArray jshortA, jboolean notSigned) {

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

CIMValue *cv=NULL;

{

jboolean b;

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

jsize len=jEnv->GetArrayLength(jshortA);

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

jshort* jsA=jEnv->GetShortArrayElements(jshortA,&b);

jint rv = -1;

if (notSigned) {

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

Array<Uint8> u8;

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

if (pos!=PEG_NOT_FOUND)

u8.append((Uint8)jsA[i]);

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

cv=new CIMValue(u8);

jEnv->ReleaseStringUTFChars(jN,str);

return rv;

}

else {

Array<Sint8> s8;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperty

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

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

s8.append((Sint8)jsA[i]);

{

cv=new CIMValue(s8);

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

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

jint rv = -1;

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

if (pos!=PEG_NOT_FOUND)

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

jEnv->ReleaseStringUTFChars(jN,str);

return rv;

}

return (jint)(void*)cv;

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1hasQualifier

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

{

CIMClass *cls = DEBUG_ConvertJavaToC (jint, 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 jint JNICALL Java_org_pegasus_jmpi_CIMValue__1shortArray

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties

(JNIEnv *jEnv, jobject jThs, jintArray jintA, jboolean notSigned) {

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

CIMValue *cv=NULL;

{

jboolean b;

JMPIjvm::cacheIDs(jEnv);

jsize len=jEnv->GetArrayLength(jintA);

jint* jiA=jEnv->GetIntArrayElements(jintA,&b);

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

if (notSigned) {

Array<Uint16> u16;

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

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

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

u16.append((Uint16)jiA[i]);

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

cv=new CIMValue(u16);

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

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

}

else {

Array<Sint16> s16;

return jVec;

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

s16.append((Sint16)jiA[i]);

cv=new CIMValue(s16);

}

return (jint)(void*)cv;

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1addProperty

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

{

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

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

cls->addProperty(*p);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1intArray

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1setProperties

(JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned) {

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

CIMValue *cv=NULL;

{

jboolean b;

JMPIjvm::cacheIDs(jEnv);

jsize len=jEnv->GetArrayLength(jlongA);

jlong* jlA=jEnv->GetLongArrayElements(jlongA,&b);

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

if (notSigned) {

Array<Uint32> u32;

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

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

cls->removeProperty(i);

u32.append((Uint32)jlA[i]);

cv=new CIMValue(u32);

}

else {

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

Array<Sint32> s32;

JMPIjvm::checkException(jEnv);

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

s32.append((Sint32)jlA[i]);

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

cv=new CIMValue(s32);

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

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

JMPIjvm::checkException(jEnv);

cls->addProperty(*cp);

}

return (jint)(void*)cv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1longArray

(JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned) {

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifiers

CIMValue *cv=NULL;

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

jboolean b;

{

jsize len=jEnv->GetArrayLength(jlongA);

JMPIjvm::cacheIDs(jEnv);

jlong* jlA=jEnv->GetLongArrayElements(jlongA,&b);

if (notSigned) {

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

Array<Uint64> u64;

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

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

u64.append((Uint64)jlA[i]);

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

cv=new CIMValue(u64);

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

}

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

else {

Array<Sint64> s64;

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

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

s64.append((Sint64)jlA[i]);

cv=new CIMValue(s64);

}

return (jint)(void*)cv;

return jVec;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1stringArray

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1new

(JNIEnv *jEnv, jobject jThs, jobjectArray jstringA) {

(JNIEnv *jEnv, jobject jThs, jstring jN)

CIMValue *cv=NULL;

{

jboolean b;

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

jsize len=jEnv->GetArrayLength(jstringA);

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

Array<String> strA;

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

jEnv->ReleaseStringUTFChars(jN,str);

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

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

return DEBUG_ConvertCToJava (CIMClass*, jint, cls);

strA.append(String(str));

jEnv->ReleaseStringUTFChars(jsA,str);

}

cv=new CIMValue(strA);

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getSuperClass

return (jint)(void*)cv;

(JNIEnv *jEnv, jobject jThs, jint jCls)

{

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

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

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

return str;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1booleanArray

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getKeys

(JNIEnv *jEnv, jobject jThs, jbooleanArray jboolA) {

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

CIMValue *cv=NULL;

{

jboolean b;

JMPIjvm::cacheIDs(jEnv);

jsize len=jEnv->GetArrayLength(jboolA);

jboolean* jbA=jEnv->GetBooleanArrayElements(jboolA,&b);

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

Array<Boolean> bA;

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

if (cls->hasKeys()) {

bA.append((Boolean)jbA[i]);

Array<CIMName> keyNames;

cv=new CIMValue(bA);

cls->getKeyNames(keyNames);

return (jint)(void*)cv;

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

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

if (pos!=PEG_NOT_FOUND){

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

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

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

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

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1refArray

return jVec;

(JNIEnv *jEnv, jobject jThs, jintArray jintA) {

CIMValue *cv=NULL;

jboolean b;

jsize len=jEnv->GetArrayLength(jintA);

jint* jiA=jEnv->GetIntArrayElements(jintA,&b);

Array<CIMObjectPath> cA;

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

cA.append(*((CIMObjectPath*)jiA[i]));

cv=new CIMValue(cA);

return (jint)(void*)cv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethod

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

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

CIMValue *cv=(CIMValue*)jP;

{

return (jint)cv->getType();

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

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

jint rv = -1;

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

if (pos!=PEG_NOT_FOUND) {

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

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString

jEnv->ReleaseStringUTFChars(jN,str);

(JNIEnv *jEnv, jobject jThs, jint jV) {

CIMValue *cv=(CIMValue*)jV;

return rv;

return (jstring)jEnv->NewStringUTF(cv->toString().getCString());

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMValue__1getValue

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1equals

(JNIEnv *jEnv, jobject jThs, jint jV) {

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

CIMValue *cv=(CIMValue*)jV;

{

if (cv->isNull())

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

return NULL;

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

CIMType type=cv->getType();

if (!cv->isArray()) {

return cls->identical(*clsToBeCompared);

switch (type) {

case CIMTYPE_BOOLEAN:

Boolean bo;

cv->get(bo);

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

break;

case CIMTYPE_SINT8:

Sint8 s8;

cv->get(s8);

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

break;

case CIMTYPE_UINT8:

Uint8 u8;

cv->get(u8);

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

break;

case CIMTYPE_SINT16:

Sint16 s16;

cv->get(s16);

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

break;

case CIMTYPE_UINT16:

Uint16 u16;

cv->get(u16);

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

break;

case CIMTYPE_SINT32:

Sint32 s32;

cv->get(s32);

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

break;

case CIMTYPE_UINT32:

Uint32 u32;

cv->get(u32);

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

break;

case CIMTYPE_SINT64:

Sint64 s64;

cv->get(s64);

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

break;

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

}

break;

case CIMTYPE_REAL32:

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1finalize

float f;

(JNIEnv *jEnv, jobject jThs, jint jCls)

cv->get(f);

{

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

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

break;

case CIMTYPE_REAL64:

delete cls;

double d;

cv->get(d);

DEBUG_ConvertCleanup (jint, jCls);

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

break;

case CIMTYPE_STRING: {

String s;

jstring str;

cv->get(s);

str=jEnv->NewStringUTF(s.getCString());

return str;

}

break;

case CIMTYPE_REFERENCE: {

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1filterProperties

CIMObjectPath ref;

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

cv->get(ref);

{

return jEnv->NewObject(classRefs[12],instanceMethodIDs[12],

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

(jint)new CIMObjectPath(ref));

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

}

break;

else if (jPl) {

case CIMTYPE_CHAR16:

CIMPropertyList pl = getList(jEnv,jPl);

throwCIMException(jEnv,"+++ Char16 not yet supported");

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

break;

case CIMTYPE_DATETIME: {

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

CIMDateTime dt;

cv->get(dt);

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

return jEnv->NewObject(classRefs[24],instanceMethodIDs[35],

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

(jint)new CIMDateTime(dt));

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

}

// throwCIMException(jEnv,"+++ DateTime not yet supported");

break;

default:

throwCIMException(jEnv,"+++ unsupported type: ");

}

if (iq)

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

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

}

else if (iq) {

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

if (ic)

return DEBUG_ConvertCToJava (CIMClass*, jint, cf);

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

CIMProperty cp=cf->getProperty(i);

cp.setClassOrigin(CIMName());

cf->removeProperty(i);

cf->addProperty(cp);

}

else {

switch (type) {

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

case CIMTYPE_BOOLEAN: {

Array<Boolean> bo;

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

cv->get(bo);

CIMProperty cp = cc->getProperty(i);

int s=bo.size();

CIMName co;

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

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

if (ic)

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

co = cp.getClassOrigin();

return jbooleanA;

CIMProperty np(cp.getName(),

cp.getValue(),

cp.getArraySize(),

cp.getReferenceClassName(),

co,

cp.getPropagated());

cf->addProperty(np);

}

break;

case CIMTYPE_SINT8: {

Array<Sint8> s8;

cv->get(s8);

int s=s8.size();

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

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

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

return jbyteA;

}

break;

case CIMTYPE_UINT8: {

return DEBUG_ConvertCToJava (CIMClass*, jint, cf);

Array<Uint8> u8;

cv->get(u8);

int s=u8.size();

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

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

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

return jshortA;

}

break;

case CIMTYPE_SINT16: {

Array<Sint16> s16;

cv->get(s16);

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

int s=s16.size();

// ---

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

// - CIMInstance

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

// ---

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

return jshortA;

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1new

(JNIEnv *jEnv, jobject jThs)

{

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

}

break;

case CIMTYPE_UINT16: {

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1newCn

Array<Uint16> u16;

(JNIEnv *jEnv, jobject jThs, jstring jN)

cv->get(u16);

{

int s=u16.size();

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

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

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

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

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

jEnv->ReleaseStringUTFChars(jN,str);

return jintA;

return DEBUG_ConvertCToJava (CIMInstance*, jint, ci);

}

break;

case CIMTYPE_SINT32: {

//Added by Andy Viciu

Array<Sint32> s32;

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setName

cv->get(s32);

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

int s=s32.size();

{

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

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

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

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

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

return jintA;

jEnv->ReleaseStringUTFChars(jN,str);

/* NOT SUPPORTED AND NOT NEEDED*/

}

break;

case CIMTYPE_UINT32: {

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperty

Array<Uint32> u32;

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

cv->get(u32);

{

int s=u32.size();

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

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

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

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

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

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

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

return jlongA;

try {

if (pos!=PEG_NOT_FOUND)

{

CIMProperty cp=ci->getProperty(pos);

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

{

cp.setValue(*cv);

}

break;

else

case CIMTYPE_SINT64: {

{

Array<Sint64> s64;

DDD(PEGASUS_STD(cerr)<<"!!! CIMInstance.setProperty - Wrong type of CIMValue (instance name:"<<ci->getClassName().getString()<<", property name: "<<str<<")");

cv->get(s64);

DDD(PEGASUS_STD(cerr)<<"!!! CIMInstance.setProperty : "<<cp.getType()<<" <> "<<cv->getType()<<PEGASUS_STD(endl));

int s=s64.size();

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

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

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:

ci->removeProperty(pos);

throwCIMException(jEnv,"+++ UnisgnetInt64 not yet supported");

ci->addProperty(cp);

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;

else

case CIMTYPE_REAL64: {

{

Array<Real64> r64;

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

cv->get(r64);

ci->addProperty(*cp);

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;

Catch(jEnv);

case CIMTYPE_REFERENCE:

throwCIMException(jEnv,"+++ Reference not yet supported");

jEnv->ReleaseStringUTFChars(jN,str);

break;

case CIMTYPE_CHAR16:

throwCIMException(jEnv,"+++ Char16 not yet supported");

break;

case CIMTYPE_DATETIME:

throwCIMException(jEnv,"+++ DateTime not yet supported");

break;

default:

throwCIMException(jEnv,"+++ unsupported type: ");

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperties

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

{

throw CIMException(CIM_ERR_NOT_SUPPORTED, String("Not yet supported"));

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperty

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

{

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

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

jint rv = -1;

try {

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

if (pos != PEG_NOT_FOUND)

{

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

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

}

return NULL;

}

Catch(jEnv);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMValue__1finalize

jEnv->ReleaseStringUTFChars(jN,str);

(JNIEnv *jEnv, jobject jThs, jint jV) {

CIMValue *cv=(CIMValue*)jV;

return rv;

delete cv;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getKeyValuePairs

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

{

JMPIjvm::cacheIDs(jEnv);

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

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

// ---

// - CIMNameSpace

//@HACK

// ---

//cout << "ci->getPropertyCount() = " << ci->getPropertyCount() << endl;

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

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

//cout << ci->getProperty(i).getName ().getString ()

// << " "

// << ci->getProperty(i).getQualifierCount ()

// << " "

// << ci->getProperty(i).findQualifier(CIMName ("key"))

// << endl;

if (ci->getProperty(i).findQualifier(String("key"))!=PEG_NOT_FOUND) {

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

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

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

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

}

return jVec;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMInstance__1getClassName

(JNIEnv *jEnv, jobject jThs, jint jInst)

{

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

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

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

return str;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getQualifier

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

{

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

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

jint rv = -1;

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

if (pos!=PEG_NOT_FOUND)

{

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

}

jEnv->ReleaseStringUTFChars(jN,str);

return rv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1clone

(JNIEnv *jEnv, jobject jThs, jint jInst)

{

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

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

return DEBUG_ConvertCToJava (CIMInstance*, jint, cl);

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperties

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

{

JMPIjvm::cacheIDs(jEnv);

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

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

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

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

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

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

}

return jVec;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1finalize

(JNIEnv *jEnv, jobject jThs, jint jInst)

{

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

delete ci;

DEBUG_ConvertCleanup (jint, jInst);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1filterProperties

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

{

CIMInstance *ci = DEBUG_ConvertJavaToC (jint, 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*, jint, cf);

}

else if (jPl) {

CIMPropertyList pl=getList(jEnv,jPl);

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

cf=new CIMInstance(clsn);

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

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

if (pos!=PEG_NOT_FOUND) {

if (iq) {

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

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

cf->addProperty(cp);

}

else {

CIMProperty cp=ci->getProperty(pos);

CIMName co;

if (ic) co=cp.getClassOrigin();

CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(),

cp.getReferenceClassName(),co,cp.getPropagated());

cf->addProperty(np);

}

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

}

else if (iq) {

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

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

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

CIMProperty cp=cf->getProperty(i);

cp.setClassOrigin(CIMName());

cf->removeProperty(i);

cf->addProperty(cp);

}

else {

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

}

* Class: org_pegasus_jmpi_CIMInstance

* Method: _getObjectPath

* Signature: (I)I

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getObjectPath

(JNIEnv *jEnv, jobject jThs, jint jciCi)

{

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

CIMObjectPath *copRet = NULL;

try

{

if (ci)

{

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

copRet = new CIMObjectPath (cop);

}

Catch (jEnv);

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, copRet);

}

* Class: org_pegasus_jmpi_CIMInstance

* Method: _setObjectPath

* Signature: (II)V

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setObjectPath

(JNIEnv *jEnv, jobject jThs, jint jciCi, jint jciCop)

{

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

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

try

{

if ( ci

&& cop

)

{

ci->setPath (*cop);

}

Catch (jEnv);

}

* Class: org_pegasus_jmpi_CIMInstance

* Method: _getPropertyCount

* Signature: (I)I

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getPropertyCount

(JNIEnv *jEnv, jobject jThs, jint jciCi)

{

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

Uint32 ui32Ret = 0;

try

{

if (ci)

{

ui32Ret = ci->getPropertyCount ();

}

Catch (jEnv);

return ui32Ret;

}

* Class: org_pegasus_jmpi_CIMInstance

* Method: _getProperty

* Signature: (II)I

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getPropertyI

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

{

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

CIMProperty *cpRet = NULL;

try

{

if (ci)

{

CIMProperty cp;

cp = ci->getProperty (ji);

cpRet = new CIMProperty (cp);

}

Catch (jEnv);

return DEBUG_ConvertCToJava (CIMProperty*, jint, cpRet);

}

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

// ---

// - CIMObjectPath

// ---

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

CIMObjectPath* construct()

{

CIMObjectPath *cop = new CIMObjectPath();

_nameSpace n;

cop->setNameSpace(n.nameSpace());

cop->setHost(n.hostName());

return cop;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1new

(JNIEnv *jEnv, jobject jThs)

{

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, construct());

}

JNIEXPORT jint 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*, jint, cop);

}

JNIEXPORT jint 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*, jint, cop);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1_newCi

(JNIEnv *jEnv, jobject jThs, jint jInst)

{

CIMInstance *ci = DEBUG_ConvertJavaToC (jint, 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 DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1finalize

(JNIEnv *jEnv, jobject jThs, jint jCop)

{

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

delete cop;

DEBUG_ConvertCleanup (jint, jCop);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getHost

(JNIEnv *jEnv, jobject jThs, jint jCop)

{

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

const String &hn = cop->getHost();

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

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setHost

(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jName)

{

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

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

cop->setHost(String(str));

jEnv->ReleaseStringUTFChars(jName,str);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getObjectName

(JNIEnv *jEnv, jobject jThs, jint jCop)

{

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, 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, jint jCop, jstring jName)

{

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

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

cop->setClassName(String(str));

jEnv->ReleaseStringUTFChars(jName,str);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getNameSpace

(JNIEnv *jEnv, jobject jThs, jint jCop)

{

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, 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, jint jCop, jstring jName)

{

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

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

cop->setNameSpace(CIMNamespaceName(str));

jEnv->ReleaseStringUTFChars(jName,str);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1addKey

(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jId, jint jVal)

{

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

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

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

Array<CIMKeyBinding> keyBindings = cop->getKeyBindings();

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

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

jEnv->ReleaseStringUTFChars(jId,str);

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeys

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

{

JMPIjvm::cacheIDs(jEnv);

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

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

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(n,*cv, 0, ((CIMObjectPath) akb[i].getValue()).getClassName());

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

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

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

}

return jVec;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeyValue

(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jStr)

{

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, 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 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 DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setKeys

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

{

JMPIjvm::cacheIDs(jEnv);

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

Array<CIMKeyBinding> akb;

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

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

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

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

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

}

cop->setKeyBindings(akb);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1clone

(JNIEnv *jEnv, jobject jThs, jint jCop)

{

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

CIMObjectPath *copl = new CIMObjectPath(cop->getHost(), cop->getNameSpace(), cop->getClassName(), cop->getKeyBindings());

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, copl);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1toString

(JNIEnv *jEnv, jobject jThs, jint jCop)

{

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

const String &ns = cop->toString();

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

return str;

}

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

// ---

// - CIMDataType

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1new

(JNIEnv *jEnv, jobject jThs, jint type)

{

return DEBUG_ConvertCToJava (_dataType*, jint, new _dataType(type));

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newAr

(JNIEnv *jEnv, jobject jThs, jint type, jint size)

{

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

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newRef

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

{

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

jint cInst = DEBUG_ConvertCToJava (_dataType*, jint, new _dataType(type,String(ref)));

jEnv->ReleaseStringUTFChars(jRef,ref);

return cInst;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isArray

(JNIEnv *jEnv, jobject jThs, jint jDt)

{

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

return dt->_array==true;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isreference

(JNIEnv *jEnv, jobject jThs, jint jDt)

{

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

return dt->_reference==true;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isReference

(JNIEnv *jEnv, jobject jThs, jint jDt)

{

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

return dt->_reference==true;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getType

(JNIEnv *jEnv, jobject jThs, jint jDt)

{

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

return dt->_type;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getSize

(JNIEnv *jEnv, jobject jThs, jint jDt)

{

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

return dt->_size;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1getRefClassName

(JNIEnv *jEnv, jobject jThs, jint jDt)

{

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

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

return str;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1toString

(JNIEnv *jEnv, jobject jThs, jint jDt)

{

_dataType *dt = DEBUG_ConvertJavaToC (jint, _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, jint jDt)

{

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

delete dt;

DEBUG_ConvertCleanup (jint, jDt);

}

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

// ---

// - CIMArgument

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1getValue

(JNIEnv *jEnv, jobject jThs, jint jP)

{

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

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

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1new

(JNIEnv *jEnv, jobject jThs)

{

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

return DEBUG_ConvertCToJava (CIMParamValue*, jint, p);

}

JNIEXPORT jint 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*, jint, p);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1newSV

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

{

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

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

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

jEnv->ReleaseStringUTFChars(jN,str);

return DEBUG_ConvertCToJava (CIMParamValue*, jint, p);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setValue

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

{

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

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

cp->setValue(*cv);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMArgument__1getName

(JNIEnv *jEnv, jobject jThs, jint jP)

{

CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, 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, jint jP, jstring jN)

{

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

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

String n(str);

cp->setParameterName(n);

jEnv->ReleaseStringUTFChars(jN,str);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1getType

(JNIEnv *jEnv, jobject jThs, jint jP)

{

CIMParamValue *cp = DEBUG_ConvertJavaToC (jint, 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*, jint, type);

}

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

// ---

// - CIMProperty

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getValue

(JNIEnv *jEnv, jobject jThs, jint jP)

{

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

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

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1new

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

{

CIMProperty *p = new CIMProperty(CIMName(),CIMValue());

return DEBUG_ConvertCToJava (CIMProperty*, jint, p);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1property

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

{

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

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

CIMProperty *cp = 0;

jint jCp = -1;

try {

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

{

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

}

else

{

if (!cv->isArray())

{

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*, jint, cp);

}

Catch(jEnv);

jEnv->ReleaseStringUTFChars(jN,str);

return jCp;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setValue

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

{

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

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

cp->setValue(*cv);

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isArray

(JNIEnv *jEnv, jobject jThs, jint jP)

{

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

return (jboolean)cp->isArray();

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addValue

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

{

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

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

CIMValue cv = cp->getValue();

if (cvin->isNull())

throwCIMException(jEnv,"+++ null cvin value ");

if (!cv.isArray())

throwCIMException(jEnv,"+++ not an array ");

if (cvin->getType()!=cv.getType())

throwCIMException(jEnv,"+++ type mismatch ");

CIMType type=cv.getType();

switch (type) {

case CIMTYPE_BOOLEAN: {

Boolean bo;

cvin->get(bo);

Array<Boolean> boarr;

cv.get(boarr);

boarr.append(bo);

}

break;

case CIMTYPE_UINT8: {

Uint8 u8;

cvin->get(u8);

Array<Uint8> u8arr;

cv.get(u8arr);

u8arr.append(u8);

}

break;

case CIMTYPE_SINT8: {

Sint8 s8;

cvin->get(s8);

Array<Sint8> s8arr;

cv.get(s8arr);

s8arr.append(s8);

}

break;

case CIMTYPE_UINT16: {

Uint16 u16;

cvin->get(u16);

Array<Uint16> u16arr;

cv.get(u16arr);

u16arr.append(u16);

}

break;

case CIMTYPE_SINT16: {

Sint16 s16;

cvin->get(s16);

Array<Sint16> s16arr;

cv.get(s16arr);

s16arr.append(s16);

}

break;

case CIMTYPE_UINT32: {

Uint32 u32;

cvin->get(u32);

Array<Uint32> u32arr;

cv.get(u32arr);

u32arr.append(u32);

}

break;

case CIMTYPE_SINT32: {

Sint32 s32;

cvin->get(s32);

Array<Sint32> s32arr;

cv.get(s32arr);

s32arr.append(s32);

}

break;

case CIMTYPE_UINT64: {

Uint64 u64;

cvin->get(u64);

Array<Uint64> u64arr;

cv.get(u64arr);

u64arr.append(u64);

}

break;

case CIMTYPE_SINT64: {

Sint64 s64;

cvin->get(s64);

Array<Sint64> s64arr;

cv.get(s64arr);

s64arr.append(s64);

}

break;

case CIMTYPE_REAL32: {

Real32 f;

cvin->get(f);

Array<Real32> farr;

cv.get(farr);

farr.append(f);

}

break;

case CIMTYPE_REAL64: {

Real64 d;

cvin->get(d);

Array<Real64> darr;

cv.get(darr);

darr.append(d);

}

break;

case CIMTYPE_CHAR16: {

Char16 c16;

cvin->get(c16);

Array<Char16> c16arr;

cv.get(c16arr);

c16arr.append(c16);

}

break;

case CIMTYPE_STRING: {

String str;

cvin->get(str);

Array<String> strarr;

cv.get(strarr);

strarr.append(str);

}

break;

case CIMTYPE_DATETIME: {

CIMDateTime dt;

cvin->get(dt);

Array<CIMDateTime> dtarr;

cv.get(dtarr);

dtarr.append(dt);

}

break;

case CIMTYPE_REFERENCE: {

CIMObjectPath ref;

cvin->get(ref);

Array<CIMObjectPath> refarr;

cv.get(refarr);

refarr.append(ref);

}

break;

case CIMTYPE_OBJECT: {

CIMObject obj;

cvin->get(obj);

Array<CIMObject> objarr;

cv.get(objarr);

objarr.append(obj);

}

break;

default:

throwCIMException(jEnv,"+++ unsupported type ");

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addQualifier

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

{

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

CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);

cp->addQualifier(*cq);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getName

(JNIEnv *jEnv, jobject jThs, jint jP)

{

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

const String &n = cp->getName().getString();

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

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setName

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

{

CIMProperty *cp = DEBUG_ConvertJavaToC (jint, 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 = DEBUG_ConvertJavaToC (jint, 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 = DEBUG_ConvertJavaToC (jint, 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 = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);

String ref = cp->getReferenceClassName().getString();

bool fSuccess = false;

int iJType = 0;

_dataType *type = 0;

iJType = _dataType::convertCTypeToJavaType (cp->getType(), &fSuccess);

if (fSuccess)

{

type = new _dataType (iJType,

cp->getArraySize(),

ref.size() ? true : false,

false,

cp->isArray(),

ref,

true);

}

return DEBUG_ConvertCToJava (_dataType*, jint, type);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1setType

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

{

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

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

CIMValue val;

bool fSuccess = false;

CIMType cType = CIMTYPE_BOOLEAN;

cType = _dataType::convertJavaTypeToCType (dt->_type, &fSuccess);

if (fSuccess)

{

val.setNullValue (cType, dt->_array);

CIMProperty *np = new CIMProperty (cp->getName (), val);

delete cp;

DEBUG_ConvertCleanup (jint, jP);

return DEBUG_ConvertCToJava (CIMProperty*, jint, np);

}

else

{

return DEBUG_ConvertCToJava (CIMProperty*, jint, cp);

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMProperty__1getIdentifier

(JNIEnv *jEnv, jobject jThs, jint jP)

{

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

const String &n = cp->getName().getString();

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

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1finalize

(JNIEnv *jEnv, jobject jThs, jint jP)

{

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

delete cp;

DEBUG_ConvertCleanup (jint, jP);

}

* Class: org_pegasus_jmpi_CIMProperty

* Method: _findQualifier

* Signature: (Ljava/lang/String;)I

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1findQualifier

(JNIEnv *jEnv, jobject jThs, jint jP, jstring jQualifier)

{

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

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

int index = PEG_NOT_FOUND;

try

{

index = cp->findQualifier (CIMName (str));

jEnv->ReleaseStringUTFChars (jQualifier, str);

}

Catch (jEnv);

return index;

}

* Class: org_pegasus_jmpi_CIMProperty

* Method: _getQualifier

* Signature: (I)I

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getQualifier

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

{

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

CIMQualifier *cq = NULL;

CIMQualifier qualifier;

try

{

qualifier = cp->getQualifier ((Uint32)jIndex);

cq = new CIMQualifier (qualifier);

}

Catch (jEnv);

return DEBUG_ConvertCToJava (CIMQualifier *, jint, cq);

}

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

// ---

// - CIMQualifierType

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1new

(JNIEnv *jEnv, jobject jThs)

{

CIMQualifierDecl *qual = new CIMQualifierDecl();

return DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, qual);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1finalize

(JNIEnv *jEnv, jobject jThs, jint jQ)

{

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

delete qt;

DEBUG_ConvertCleanup (jint, jQ);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1getName

(JNIEnv *jEnv, jobject jThs, jint jQ)

{

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

const String &n = qt->getName().getString();

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

return str;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setName

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

{

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

const char *str = jEnv->GetStringUTFChars(jN,NULL);

jint jret = 0;

if (qt->isUninitialized())

{

CIMQualifierDecl *nqt = new CIMQualifierDecl(CIMName(str),CIMValue(),CIMScope());

jret = DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, nqt);

}

else

{

qt->setName(CIMName(str));

CIMQualifierDecl *nqt = new CIMQualifierDecl(*qt);

jret = DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, nqt);

}

jEnv->ReleaseStringUTFChars(jN,str);

return jret;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setValue

(JNIEnv *jEnv, jobject jThs, jint jQ,jint jV)

{

CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ);

CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);

qt->setValue(*cv);

}

// -------------------------------------

// ---

// - CIMQualifier

// ---

// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifier__1new

(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 DEBUG_ConvertCToJava (CIMQualifier*, jint, qual);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1finalize

(JNIEnv *jEnv, jobject jThs, jint jQ)

{

CIMQualifier *cq=DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);

delete cq;

DEBUG_ConvertCleanup (jint, jQ);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getName

(JNIEnv *jEnv, jobject jThs, jint jQ)

{

CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, 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

(JNIEnv *jEnv, jobject jThs, jint jQ)

{

CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);

CIMValue *cv = new CIMValue(cq->getValue());

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1setValue

(JNIEnv *jEnv, jobject jThs, jint jQ,jint jV)

{

CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);

CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);

cq->setValue(*cv);

}

// -------------------------------------

// ---

// - CIMDateTime

// ---

// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetime

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

const char *str = jEnv->GetStringUTFChars(jN,NULL);

CIMDateTime *dt = 0;

if (strlen(str)==0)

dt=new CIMDateTime();

else

dt=new CIMDateTime(String(str));

jEnv->ReleaseStringUTFChars(jN,str);

return DEBUG_ConvertCToJava (CIMDateTime*, jint, dt);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetimeempty

(JNIEnv *jEnv, jobject jThs)

{

CIMDateTime *dt = new CIMDateTime(CIMDateTime::getCurrentDateTime ());

return DEBUG_ConvertCToJava (CIMDateTime*, jint, dt);

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1after

(JNIEnv *jEnv, jobject jThs, jint jC, jint jD)

{

CIMDateTime *ct = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jC);

CIMDateTime *dt = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jD);

return (jboolean)(ct->getDifference(*ct, *dt)>0);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDateTime__1finalize

(JNIEnv *jEnv, jobject jThs, jint jDT)

{

CIMDateTime *cdt = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jDT);

delete cdt;

DEBUG_ConvertCleanup (jint, jDT);

}

// -------------------------------------

// ---

// - CIMMethod

// ---

// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1getType

(JNIEnv *jEnv, jobject jThs, jint jM)

{

CIMMethod *cm = DEBUG_ConvertJavaToC (jint, CIMMethod*, jM);

return DEBUG_ConvertCToJava (CIMType *, jint, new CIMType (cm->getType()));

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize

(JNIEnv *jEnv, jobject jThs, jint jM)

{

CIMMethod *cm = DEBUG_ConvertJavaToC (jint, CIMMethod*, jM);

delete cm;

DEBUG_ConvertCleanup (jint, jM);

}

// -------------------------------------

// ---

// - CIMValue

// ---

// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byte

(JNIEnv *jEnv, jobject jThs, jbyte jb, jboolean notSigned)

{

CIMValue *cv = NULL;

if (notSigned)

cv=new CIMValue((Uint8)jb);

else

cv=new CIMValue((Sint8)jb);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1short

(JNIEnv *jEnv, jobject jThs, jshort js, jboolean notSigned)

{

CIMValue *cv = NULL;

if (notSigned)

cv=new CIMValue((Uint16)js);

else

cv=new CIMValue((Sint16)js);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1makeInt

(JNIEnv *jEnv, jobject jThs, jlong ji, jboolean notSigned)

{

CIMValue *cv = NULL;

if (notSigned)

cv = new CIMValue((Uint32)ji);

else

cv = new CIMValue((Sint32)ji);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1long

(JNIEnv *jEnv, jobject jThs, jlong jl, jboolean notSigned)

{

CIMValue *cv = NULL;

if (notSigned)

cv=new CIMValue((Uint64)jl);

else

cv=new CIMValue((Sint64)jl);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1float

(JNIEnv *jEnv, jobject jThs, jfloat jF)

{

CIMValue *cv = new CIMValue(jF);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1double

(JNIEnv *jEnv, jobject jThs, jdouble jD)

{

CIMValue *cv = new CIMValue(jD);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1string

(JNIEnv *jEnv, jobject jThs, jstring jS)

{

const char *str = jEnv->GetStringUTFChars(jS,NULL);

CIMValue *cv = new CIMValue(String(str));

jEnv->ReleaseStringUTFChars(jS,str);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1cop

(JNIEnv *jEnv, jobject jThs, jint jR)

{

CIMObjectPath *ref = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jR);

CIMValue *cv = new CIMValue(*ref);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1datetime

(JNIEnv *jEnv, jobject jThs, jint jDT)

{

CIMDateTime *dt = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jDT);

CIMValue *cv = new CIMValue(*dt);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1char16

(JNIEnv *jEnv, jobject jThs, jchar jChar16)

{

Char16 c16 (jChar16);

CIMValue *cv = new CIMValue(c16);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1object

(JNIEnv *jEnv, jobject jThs, jint jO)

{

CIMObject *co = DEBUG_ConvertJavaToC (jint, CIMObject*, jO);

CIMValue *cv = new CIMValue(*co);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMValue__1isArray

(JNIEnv *jEnv, jobject jThs, jint jP)

{

CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jP);

return (jboolean)cv->isArray();

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1boolean

(JNIEnv *jEnv, jobject jThs, jboolean jB)

{

CIMValue *cv = new CIMValue((Boolean)jB);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byteArray

(JNIEnv *jEnv, jobject jThs, jshortArray jshortA, jboolean notSigned)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength(jshortA);

jshort *jsA = jEnv->GetShortArrayElements(jshortA,&b);

if (notSigned) {

Array<Uint8> u8;

for (jsize i=0;i<len;i++)

u8.append((Uint8)jsA[i]);

cv=new CIMValue(u8);

}

else {

Array<Sint8> s8;

for (jsize i=0;i<len;i++)

s8.append((Sint8)jsA[i]);

cv=new CIMValue(s8);

}

jEnv->ReleaseShortArrayElements(jshortA, jsA, len);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1shortArray

(JNIEnv *jEnv, jobject jThs, jintArray jintA, jboolean notSigned)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength(jintA);

jint *jiA = jEnv->GetIntArrayElements(jintA,&b);

if (notSigned) {

Array<Uint16> u16;

for (jsize i=0;i<len;i++)

u16.append((Uint16)jiA[i]);

cv=new CIMValue(u16);

}

else {

Array<Sint16> s16;

for (jsize i=0;i<len;i++)

s16.append((Sint16)jiA[i]);

cv=new CIMValue(s16);

}

jEnv->ReleaseIntArrayElements(jintA, jiA, len);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1intArray

(JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength(jlongA);

jlong *jlA = jEnv->GetLongArrayElements(jlongA,&b);

if (notSigned) {

Array<Uint32> u32;

for (jsize i=0;i<len;i++)

u32.append((Uint32)jlA[i]);

cv=new CIMValue(u32);

}

else {

Array<Sint32> s32;

for (jsize i=0;i<len;i++)

s32.append((Sint32)jlA[i]);

cv=new CIMValue(s32);

}

jEnv->ReleaseLongArrayElements(jlongA, jlA, len);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1longArray

(JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength(jlongA);

jlong *jlA = jEnv->GetLongArrayElements(jlongA,&b);

if (notSigned) {

Array<Uint64> u64;

for (jsize i=0;i<len;i++)

u64.append((Uint64)jlA[i]);

cv=new CIMValue(u64);

}

else {

Array<Sint64> s64;

for (jsize i=0;i<len;i++)

s64.append((Sint64)jlA[i]);

cv=new CIMValue(s64);

}

jEnv->ReleaseLongArrayElements(jlongA, jlA, len);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1stringArray

(JNIEnv *jEnv, jobject jThs, jobjectArray jstringA)

{

CIMValue *cv = NULL;

jsize len = jEnv->GetArrayLength(jstringA);

Array<String> strA;

for (jsize i=0;i<len;i++) {

jstring jsA = (jstring)jEnv->GetObjectArrayElement(jstringA,i);

const char *str = jEnv->GetStringUTFChars(jsA,NULL);

strA.append(String(str));

jEnv->ReleaseStringUTFChars(jsA,str);

}

cv = new CIMValue(strA);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1booleanArray

(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);

jEnv->ReleaseBooleanArrayElements(jboolA, jbA, len);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1floatArray

(JNIEnv *jEnv, jobject jThs, jfloatArray jfloatA)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength(jfloatA);

jfloat *jfA = jEnv->GetFloatArrayElements(jfloatA,&b);

Array<float> fA;

for (jsize i=0;i<len;i++)

fA.append((float)jfA[i]);

cv=new CIMValue(fA);

jEnv->ReleaseFloatArrayElements(jfloatA, jfA, len);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1doubleArray

(JNIEnv *jEnv, jobject jThs, jdoubleArray jdoubleA)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength(jdoubleA);

jdouble *jdA = jEnv->GetDoubleArrayElements(jdoubleA,&b);

Array<double> dA;

for (jsize i=0;i<len;i++)

dA.append((double)jdA[i]);

cv=new CIMValue(dA);

jEnv->ReleaseDoubleArrayElements(jdoubleA, jdA, len);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1copArray

(JNIEnv *jEnv, jobject jThs, jintArray jintA)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength(jintA);

jint *jiA = jEnv->GetIntArrayElements(jintA,&b);

Array<CIMObjectPath> cA;

for (jsize i=0;i<len;i++)

cA.append(*((CIMObjectPath*)jiA[i]));

cv=new CIMValue(cA);

jEnv->ReleaseIntArrayElements(jintA, jiA, len);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1datetimeArray

(JNIEnv *jEnv, jobject jThs, jintArray jintA)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength(jintA);

jint *jiA = jEnv->GetIntArrayElements(jintA,&b);

Array<CIMDateTime> cA;

for (jsize i=0;i<len;i++)

cA.append(*((CIMDateTime*)jiA[i]));

cv=new CIMValue(cA);

jEnv->ReleaseIntArrayElements(jintA, jiA, len);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1objectArray

(JNIEnv *jEnv, jobject jThs, jintArray jintA)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength(jintA);

jint *jiA = jEnv->GetIntArrayElements(jintA,&b);

Array<CIMObject> cA;

for (jsize i=0;i<len;i++)

cA.append(*((CIMObject*)jiA[i]));

cv=new CIMValue(cA);

jEnv->ReleaseIntArrayElements(jintA, jiA, len);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1char16Array

(JNIEnv *jEnv, jobject jThs, jcharArray jcharA)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength(jcharA);

jchar *jcA = jEnv->GetCharArrayElements(jcharA,&b);

Array<Char16> cA;

for (jsize i=0;i<len;i++)

cA.append(Char16 (jcA[i]));

cv=new CIMValue(cA);

jEnv->ReleaseCharArrayElements(jcharA, jcA, len);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType

(JNIEnv *jEnv, jobject jThs, jint jP)

{

CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jP);

bool fSuccess = false;

int iJType = 0;

iJType = _dataType::convertCTypeToJavaType (cv->getType(), &fSuccess);

return DEBUG_ConvertCToJava (int, jint, iJType);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString

(JNIEnv *jEnv, jobject jThs, jint jV)

{

CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);

return (jstring)jEnv->NewStringUTF(cv->toString().getCString());

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMValue__1getValue

(JNIEnv *jEnv, jobject jThs, jint jV)

{

JMPIjvm::cacheIDs(jEnv);

CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);

if (cv->isNull ())

return NULL;

CIMType type = cv->getType ();

if (!cv->isArray ())

{

switch (type)

{

case CIMTYPE_BOOLEAN:

Boolean bo;

cv->get(bo);

return jEnv->NewObject (JMPIjvm::jv.BooleanClassRef,

JMPIjvm::jv.BooleanNewZ,

bo);

case CIMTYPE_SINT8:

Sint8 s8;

cv->get(s8);

return jEnv->NewObject (JMPIjvm::jv.ByteClassRef,

JMPIjvm::jv.ByteNewB,

s8);

case CIMTYPE_UINT8:

Uint8 u8;

cv->get(u8);

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef,

JMPIjvm::jv.UnsignedInt8NewS,

u8);

case CIMTYPE_SINT16:

Sint16 s16;

cv->get(s16);

return jEnv->NewObject (JMPIjvm::jv.ShortClassRef,

JMPIjvm::jv.ShortNewS,

s16);

case CIMTYPE_UINT16:

Uint16 u16;

cv->get(u16);

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef,

JMPIjvm::jv.UnsignedInt16NewI,

u16);

case CIMTYPE_SINT32:

Sint32 s32;

cv->get(s32);

return jEnv->NewObject (JMPIjvm::jv.IntegerClassRef,

JMPIjvm::jv.IntegerNewI,

s32);

case CIMTYPE_UINT32:

Uint32 u32;

cv->get(u32);

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef,

JMPIjvm::jv.UnsignedInt32NewJ,

u32);

case CIMTYPE_SINT64:

Sint64 s64;

cv->get(s64);

return jEnv->NewObject (JMPIjvm::jv.LongClassRef,

JMPIjvm::jv.LongNewJ,

s64);

case CIMTYPE_UINT64:

{

Uint64 u64;

cv->get(u64);

jobject jBIG = jEnv->CallStaticObjectMethod (JMPIjvm::jv.BigIntegerClassRef,

JMPIjvm::jv.BigIntegerValueOf,

u64);

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,

JMPIjvm::jv.UnsignedInt64NewBi,

jBIG);

}

case CIMTYPE_REAL32:

float f;

cv->get(f);

return jEnv->NewObject (JMPIjvm::jv.FloatClassRef,

JMPIjvm::jv.FloatNewF,

f);

case CIMTYPE_REAL64:

double d;

cv->get(d);

return jEnv->NewObject (JMPIjvm::jv.DoubleClassRef,

JMPIjvm::jv.DoubleNewD,

d);

case CIMTYPE_STRING:

{

String s;

cv->get(s);

return jEnv->NewStringUTF(s.getCString());

}

case CIMTYPE_REFERENCE:

{

CIMObjectPath ref;

cv->get(ref);

jint jOp = DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(ref));

return jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef,

JMPIjvm::jv.CIMObjectPathNewI,

jOp);

}

case CIMTYPE_CHAR16:

{

Char16 c16;

cv->get(c16);

return jEnv->NewObject (JMPIjvm::jv.CharacterClassRef,

JMPIjvm::jv.CharacterNewC,

(jchar)c16);

}

case CIMTYPE_DATETIME:

{

CIMDateTime dt;

cv->get(dt);

jint jDT = DEBUG_ConvertCToJava (CIMDateTime*, jint, new CIMDateTime(dt));

return jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef,

JMPIjvm::jv.CIMDateTimeNewI,

jDT);

}

case CIMTYPE_OBJECT:

{

CIMObject co;

cv->get(co);

if (co.isClass ())

{

jint jCC = DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass(co));

return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,

JMPIjvm::jv.CIMObjectNewIZ,

jCC,

(jboolean)true);

}

else

{

jint jCI = DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance(co));

return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,

JMPIjvm::jv.CIMObjectNewIZ,

jCI,

(jboolean)false);

}

default:

throwCIMException(jEnv,"+++ unsupported type: ");

}

else

{

switch (type)

{

case CIMTYPE_BOOLEAN:

{

Array<Boolean> bo;

cv->get(bo);

int s = bo.size();

jobjectArray jbooleanA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.BooleanClassRef,

0);

for (int i=0; i < s; i++)

jEnv->SetObjectArrayElement(jbooleanA,

jEnv->NewObject (JMPIjvm::jv.BooleanClassRef,

JMPIjvm::jv.BooleanNewZ,

bo[i]));

return jbooleanA;

}

case CIMTYPE_SINT8:

{

Array<Sint8> s8;

cv->get(s8);

int s = s8.size();

jobjectArray jbyteA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.ByteClassRef,

0);

for (int i=0; i < s; i++)

jEnv->SetObjectArrayElement (jbyteA,

jEnv->NewObject (JMPIjvm::jv.ByteClassRef,

JMPIjvm::jv.ByteNewB,

s8[i]));

return jbyteA;

}

case CIMTYPE_UINT8:

{

Array<Uint8> u8;

cv->get(u8);

int s = u8.size();

jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.UnsignedInt8ClassRef,

0);

for (int i=0; i < s; i++)

jEnv->SetObjectArrayElement (jshortA,

jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef,

JMPIjvm::jv.UnsignedInt8NewS,

u8[i]));

return jshortA;

}

case CIMTYPE_SINT16:

{

Array<Sint16> s16;

cv->get(s16);

int s = s16.size();

jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.ShortClassRef,

0);

for (int i=0; i < s; i++)

jEnv->SetObjectArrayElement (jshortA,

jEnv->NewObject (JMPIjvm::jv.ShortClassRef,

JMPIjvm::jv.ShortNewS,

s16[i]));

return jshortA;

}

case CIMTYPE_UINT16:

{

Array<Uint16> u16;

cv->get(u16);

int s = u16.size();

jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.UnsignedInt16ClassRef,

0);

for (int i=0; i < s; i++)

jEnv->SetObjectArrayElement (jintA,

jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef,

JMPIjvm::jv.UnsignedInt16NewI,

u16[i]));

return jintA;

}

case CIMTYPE_SINT32:

{

Array<Sint32> s32;

cv->get(s32);

int s = s32.size();

jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.IntegerClassRef,

0);

for (int i=0; i < s; i++)

jEnv->SetObjectArrayElement (jintA,

jEnv->NewObject (JMPIjvm::jv.IntegerClassRef,

JMPIjvm::jv.IntegerNewI,

s32[i]));

return jintA;

}

case CIMTYPE_UINT32:

{

Array<Uint32> u32;

cv->get(u32);

int s = u32.size();

jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.UnsignedInt32ClassRef,

0);

for (int i=0; i < s; i++)

jEnv->SetObjectArrayElement (jlongA,

jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef,

JMPIjvm::jv.UnsignedInt32NewJ,

u32[i]));

return jlongA;

}

case CIMTYPE_SINT64:

{

Array<Sint64> s64;

cv->get(s64);

int s = s64.size();

jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.LongClassRef,

0);

for (int i=0; i < s; i++)

jEnv->SetObjectArrayElement (jlongA,

jEnv->NewObject (JMPIjvm::jv.LongClassRef,

JMPIjvm::jv.LongNewJ,

s64[i]));

return jlongA;

}

case CIMTYPE_UINT64:

{

Array<Uint64> u64;

cv->get(u64);

int s = u64.size();

jobjectArray ju64A = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.UnsignedInt64ClassRef,

0);

for (int i=0; i < s; i++)

{

jobject jBIG = jEnv->CallStaticObjectMethod (JMPIjvm::jv.BigIntegerClassRef,

JMPIjvm::jv.BigIntegerValueOf,

u64[i]);

jEnv->SetObjectArrayElement (ju64A,

jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,

JMPIjvm::jv.UnsignedInt64NewBi,

jBIG));

}

return ju64A;

}

case CIMTYPE_REAL32:

{

Array<Real32> r32;

cv->get(r32);

int s = r32.size();

jobjectArray jfloatA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.FloatClassRef,

0);

for (int i=0; i < s; i++)

jEnv->SetObjectArrayElement (jfloatA,

jEnv->NewObject (JMPIjvm::jv.FloatClassRef,

JMPIjvm::jv.FloatNewF,

r32[i]));

return jfloatA;

}

case CIMTYPE_REAL64:

{

Array<Real64> r64;

cv->get(r64);

int s = r64.size();

jobjectArray jdoubleA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.DoubleClassRef,

0);

for (int i=0; i < s; i++)

jEnv->SetObjectArrayElement (jdoubleA,

jEnv->NewObject (JMPIjvm::jv.DoubleClassRef,

JMPIjvm::jv.DoubleNewD,

r64[i]));

return jdoubleA;

}

case CIMTYPE_STRING:

{

Array<String> str;

cv->get(str);

int s = str.size();

jobjectArray jstringA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.StringClassRef,

0);

for (int i=0; i < s; i++)

jEnv->SetObjectArrayElement (jstringA,

jEnv->NewStringUTF (str[i].getCString()));

return jstringA;

}

case CIMTYPE_REFERENCE:

{

Array<CIMObjectPath> ref;

cv->get(ref);

int s = ref.size();

jobjectArray jrefA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.CIMObjectPathClassRef,

0);

for (int i=0; i < s; i++)

{

jint jOP = DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(ref[i]));

jEnv->SetObjectArrayElement (jrefA,

jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef,

JMPIjvm::jv.CIMObjectPathNewI,

jOP));

}

return jrefA;

}

case CIMTYPE_CHAR16:

{

Array<Char16> c16;

cv->get(c16);

int s = c16.size();

jobjectArray jc16A = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.CharacterClassRef,

0);

for (int i=0; i < s; i++)

jEnv->SetObjectArrayElement (jc16A,

jEnv->NewObject (JMPIjvm::jv.CharacterClassRef,

JMPIjvm::jv.CharacterNewC,

(jchar)c16[i]));

return jc16A;

}

case CIMTYPE_DATETIME:

{

Array<CIMDateTime> dt;

cv->get(dt);

int s = dt.size();

jobjectArray jdtA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.CIMDateTimeClassRef,

0);

for (int i=0; i < s; i++)

{

jint jDT = DEBUG_ConvertCToJava (CIMDateTime*, jint, new CIMDateTime(dt[i]));

jEnv->SetObjectArrayElement (jdtA,

jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef,

JMPIjvm::jv.CIMDateTimeNewI,

jDT));

}

return jdtA;

}

case CIMTYPE_OBJECT:

{

Array<CIMObject> co;

cv->get(co);

int s = co.size();

jobjectArray jcoA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.CIMObjectClassRef,

0);

for (int i=0; i < s; i++)

{

if (co[i].isClass ())

{

jint jCC = DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass(co[i]));

jEnv->SetObjectArrayElement (jcoA,

jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,

JMPIjvm::jv.CIMObjectNewIZ,

jCC,

(jboolean)true));

}

else

{

jint jCI = DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance(co[i]));

jEnv->SetObjectArrayElement (jcoA,

jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,

JMPIjvm::jv.CIMObjectNewIZ,

jCI,

(jboolean)false));

}

return jcoA;

}

default:

throwCIMException(jEnv,"+++ unsupported type: ");

}

return NULL;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMValue__1finalize

(JNIEnv *jEnv, jobject jThs, jint jV)

{

CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);

delete cv;

DEBUG_ConvertCleanup (jint, jV);

}

// -------------------------------------

// ---

// - 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 ((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_;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1new

(JNIEnv *jEnv, jobject jThs)

{

return DEBUG_ConvertCToJava (_nameSpace*, jint, new _nameSpace());

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHn

(JNIEnv *jEnv, jobject jThs, jstring jHn)

{

const char *hn = jEnv->GetStringUTFChars(jHn,NULL);

jint cInst = DEBUG_ConvertCToJava (_nameSpace*, jint, new _nameSpace(hn));

jEnv->ReleaseStringUTFChars(jHn,hn);

return cInst;

}

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 = DEBUG_ConvertCToJava (_nameSpace*, jint, new _nameSpace(String(hn),String(ns)));

jEnv->ReleaseStringUTFChars(jHn,hn);

jEnv->ReleaseStringUTFChars(jNs,ns);

return cInst;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getHost

(JNIEnv *jEnv, jobject jThs, jint jNs)

{

_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);

const String &hn = cNs->hostName_;

jstring str = jEnv->NewStringUTF(hn.getCString());

return str;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getNameSpace

(JNIEnv *jEnv, jobject jThs, jint jNs)

{

_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);

const String &ns = cNs->nameSpace_;

jstring str = jEnv->NewStringUTF(ns.getCString());

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setHost

(JNIEnv *jEnv, jobject jThs, jint jNs, jstring jHn)

{

_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);

const char *str = jEnv->GetStringUTFChars(jHn,NULL);

cNs->port_=0;

cNs->hostName_=str;

jEnv->ReleaseStringUTFChars(jHn,str);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setNameSpace

(JNIEnv *jEnv, jobject jThs, jint jNs, jstring jN)

{

_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);

const char *str = jEnv->GetStringUTFChars(jN,NULL);

cNs->nameSpace_=str;

jEnv->ReleaseStringUTFChars(jN,str);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1finalize

(JNIEnv *jEnv, jobject jThs, jint jNs)

{

_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);

delete cNs;

DEBUG_ConvertCleanup (jint, jNs);

}

// -------------------------------------

// ---

// - Enumerators

// ---

// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1getClass

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)

{

Array<CIMClass> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMClass>*, jEnum);

return DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass((*enm)[pos]));

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1size

(JNIEnv *jEnv, jobject jThs, jint jEnum)

{

Array<CIMClass> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMClass>*, jEnum);

return enm->size();

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1getInstance

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)

{

Array<CIMInstance> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMInstance>*, jEnum);

return DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance((*enm)[pos]));

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1size

(JNIEnv *jEnv, jobject jThs, jint jEnum)

{

Array<CIMInstance> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMInstance>*, jEnum);

return enm->size();

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1getObjectPath

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)

{

Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMObjectPath>*, jEnum);

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath((*enm)[pos]));

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1size

(JNIEnv *jEnv, jobject jThs, jint jEnum)

{

Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMObjectPath>*, jEnum);

return enm->size();

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1getQualifierType

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)

{

Array<CIMQualifierDecl> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMQualifierDecl>*, jEnum);

return DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, new CIMQualifierDecl((*enm)[pos]));

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1size

(JNIEnv *jEnv, jobject jThs, jint jEnum)

{

Array<CIMQualifierDecl> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMQualifierDecl>*, jEnum);

return enm->size();

}

// -------------------------------------

// ---

// - CIMClient

// ---

// -------------------------------------

void checkNs(CIMObjectPath *cop, jint jNs) {

if (cop->getNameSpace().isNull()) {

_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);

cop->setNameSpace(CIMNamespaceName(cNs->nameSpace()));

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1newNaUnPw

(JNIEnv *jEnv, jobject jThs, jint jNs, jstring jUn, jstring jPw)

{

_nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);

const char *un = jEnv->GetStringUTFChars(jUn,NULL);

const char *pw = jEnv->GetStringUTFChars(jPw,NULL);

jint jCc = 0;

try {

CIMClient *cc=new CIMClient();

cc->connect(cNs->hostName(),cNs->port(),un,pw);

jCc = DEBUG_ConvertCToJava (CIMClient*, jint, cc);

}

Catch(jEnv);

jEnv->ReleaseStringUTFChars(jUn,un);

jEnv->ReleaseStringUTFChars(jPw,pw);

return jCc;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1disconnect

(JNIEnv *jEnv, jobject jThs, jint jCc)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

try {

cCc->disconnect();

}

Catch(jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getClass

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean lo,

jboolean iq, jboolean ic, jobjectArray jPl)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

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 DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass(cls));

}

Catch(jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteClass

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, 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, jint jCc, jint jNs, jint jCop, int jCl)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMClass *cl = DEBUG_ConvertJavaToC (jint, CIMClass*, jCl);

try {

cCc->createClass(cop->getNameSpace(),*cl);

}

Catch(jEnv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setClass

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jCl)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMClass *cl = DEBUG_ConvertJavaToC (jint, CIMClass*, jCl);

try {

checkNs(cop,jNs);

cCc->modifyClass(cop->getNameSpace(),*cl);

}

Catch(jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClasses

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, int jCop, jboolean deep, jboolean lo, jboolean iq, jboolean ic)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

try {

checkNs(cop,jNs);

Array<CIMClass> enm=cCc->enumerateClasses(

cop->getNameSpace(),cop->getClassName(),(Boolean)deep,(Boolean)lo,(Boolean)iq,(Boolean)ic);

return DEBUG_ConvertCToJava (Array<CIMClass>*, jint, new Array<CIMClass>(enm));

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClassNames

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, 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>*, jint, enmop);

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateQualifiers

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, int jCop)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

try {

checkNs(cop,jNs);

Array<CIMQualifierDecl> enm=cCc->enumerateQualifiers(cop->getNameSpace());

return DEBUG_ConvertCToJava (Array<CIMQualifierDecl>*, jint, new Array<CIMQualifierDecl>(enm));

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getInstance

(JNIEnv *jEnv, jobject jThs, jint jCc, int jNs, int jCop, jboolean lo,

jboolean iq, jboolean ic, jobjectArray jPl)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMPropertyList pl = getList(jEnv,jPl);

try {

checkNs(cop,jNs);

CIMInstance inst=cCc->getInstance(cop->getNameSpace(),

*cop,

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,

pl);

return DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance(inst));

}

Catch(jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteInstance

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

try {

checkNs(cop,jNs);

cCc->deleteInstance(cop->getNameSpace(),*cop);

}

Catch(jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1createInstance

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, int jCi)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);

try {

checkNs(cop,jNs);

ci->setPath(*cop);

CIMObjectPath obj=cCc->createInstance(cop->getNameSpace(),*ci);

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(obj));

}

Catch(jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1modifyInstance

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jCi,

jboolean iq, jobjectArray jPl)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);

CIMPropertyList pl = getList(jEnv,jPl);

try {

checkNs(cop,jNs);

ci->setPath(*cop);

cCc->modifyInstance(cop->getNameSpace(),*ci,(Boolean)iq,pl);

}

Catch(jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstances

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep, jboolean lo,

jboolean iq, jboolean ic, jobjectArray jPl)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMPropertyList pl = getList(jEnv,jPl);

try {

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>*, jint, new Array<CIMInstance>(enm));

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstanceNames

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

try {

checkNs(cop,jNs);

Array<CIMObjectPath> enm=cCc->enumerateInstanceNames(

cop->getNameSpace(),cop->getClassName()); //,(Boolean)deep);

return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm));

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getQualifier

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

try {

checkNs(cop,jNs);

CIMQualifierDecl *val=new CIMQualifierDecl(cCc->getQualifier(cop->getNameSpace(),cop->getClassName()));

return DEBUG_ConvertCToJava (CIMQualifierDecl*, 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 = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

try {

checkNs(cop,jNs);

cCc->deleteQualifier(cop->getNameSpace(),cop->getClassName());

}

Catch(jEnv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setQualifier

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jQ)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ);

try {

checkNs(cop,jNs);

cCc->setQualifier(cop->getNameSpace(),*qt);

}

Catch(jEnv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

const char *str = jEnv->GetStringUTFChars(jPn,NULL);

CIMName pName(str);

jint jCv = 0;

try {

checkNs(cop,jNs);

CIMValue *val = new CIMValue(cCc->getProperty(cop->getNameSpace(),*cop,pName));

jCv = DEBUG_ConvertCToJava (CIMValue*, jint, val);

}

Catch(jEnv);

jEnv->ReleaseStringUTFChars(jPn,str);

return jCv;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn, jint jV)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMValue *val = DEBUG_ConvertJavaToC (jint, 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 jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn, jobject jIn, jobject jOut)

{

JMPIjvm::cacheIDs(jEnv);

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

const char *str = jEnv->GetStringUTFChars(jMn,NULL);

CIMName method(str);

jint jCv = 0;

Array<CIMParamValue> in;

Array<CIMParamValue> out;

for (int i=0,m=jEnv->CallIntMethod(jIn,JMPIjvm::jv.VectorSize); i<m; i++) {

JMPIjvm::checkException(jEnv);

jobject jProp=jEnv->CallObjectMethod(jIn,JMPIjvm::jv.VectorElementAt,i);

JMPIjvm::checkException(jEnv);

jint jp = jEnv->CallIntMethod(jProp,JMPIjvm::jv.CIMPropertyCInst);

CIMProperty *p = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp);

JMPIjvm::checkException(jEnv);

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,v.getArraySize());

jint jp = DEBUG_ConvertCToJava (CIMProperty*, jint, p);

jobject prop = jEnv->NewObject(JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jp);

jEnv->CallVoidMethod(jOut,JMPIjvm::jv.VectorAddElement,prop);

}

jCv = DEBUG_ConvertCToJava (CIMValue*, jint, val);

}

Catch(jEnv);

jEnv->ReleaseStringUTFChars(jMn,str);

return jCv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod24

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn,

jobjectArray jIn, jobjectArray jOut)

{

JMPIjvm::cacheIDs(jEnv);

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

const char *str = jEnv->GetStringUTFChars(jMn,NULL);

CIMName method(str);

jint jCv = 0;

Array<CIMParamValue> in;

Array<CIMParamValue> out;

for (int i=0,m=jEnv->GetArrayLength(jIn); i<m; i++) {

JMPIjvm::checkException(jEnv);

_nameSpace::_nameSpace() {

jobject jArg=jEnv->GetObjectArrayElement(jIn,i);

port_=0;

JMPIjvm::checkException(jEnv);

hostName_=System::getHostName();

nameSpace_="root/cimv2";

}

_nameSpace::_nameSpace(String hn) {

jint jp = jEnv->CallIntMethod(jArg,JMPIjvm::jv.CIMArgumentCInst);

port_=0;

CIMParamValue *p = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jp);

hostName_=hn;

nameSpace_="root/cimv2";

}

_nameSpace::_nameSpace(String hn, String ns) {

JMPIjvm::checkException(jEnv);

port_=0;

hostName_=hn;

nameSpace_=ns;

}

int _nameSpace::port() {

in.append(*p);

if (port_) return port_;

port_=5988;

if (hostName_.subString(0,7)=="http://") {

protocol_="http://";

hostName_=hostName_.subString(7);

}

Sint32 p=hostName_.reverseFind(':');

try {

if (p>=0) {

checkNs(cop,jNs);

if (isdigit(hostName_[p+1]))

CIMValue *val=new CIMValue(cCc->invokeMethod(cop->getNameSpace(),*cop,method,in,out));

port_=atoi(hostName_.subString(p+1).getCString());

hostName_.remove(p);

for (int i=0,m=out.size(),o=jEnv->GetArrayLength(jOut); i<m && i<o; i++) {

CIMParamValue *parm = new CIMParamValue (out[i]);

jint jParm = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);

jEnv->SetObjectArrayElement(jOut,

jEnv->NewObject(JMPIjvm::jv.CIMArgumentClassRef,JMPIjvm::jv.CIMArgumentNewI,jParm));

}

return port_;

jCv = DEBUG_ConvertCToJava (CIMValue*, jint, val);

}

Catch(jEnv);

String _nameSpace::hostName() {

jEnv->ReleaseStringUTFChars(jMn,str);

port();

return hostName_;

}

String _nameSpace::nameSpace() {

return jCv;

return nameSpace_;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jQuery, jstring jQl)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

const char *str = jEnv->GetStringUTFChars(jQuery,NULL);

String query(str);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1new

/* @NOTE

(JNIEnv *jEnv, jobject jThs) {

** This does not work for some reason on the client java code:

return (jint)(void*) new _nameSpace();

** DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::Java_org_pegasus_jmpi_CIMClient__1execQuery: jEnv = "<<PEGASUS_STD(hex)<<(int)jEnv<<", jThs = "<<(int)jThs<<PEGASUS_STD(dec)<<", jCc = "<<jCc<<", jNs = "<<jNs<<", jCop = "<<jCop<<", jQuery = "<<PEGASUS_STD(hex)<<(int)jQuery<<", jQl = "<<(int)jQl<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

}

** What does work is:

** printf ("This is a test\n");

** To debug these JNI functions insert the following:

** if (getenv ("PEGASUS_JMPI_GDB"))

** {

** bool fLoop = true;

** int i = 0;

** while (fLoop)

** {

** i = 1;

** }

** Export the variable PEGASUS_JMPI_GDB=1.

** Start gdb in another process.

** shell ps -efl

** att <ps number>

** set fLoop = 0

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHn

jEnv->ReleaseStringUTFChars(jQuery,str);

(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;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHnNs

str=jEnv->GetStringUTFChars(jQl,NULL);

(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;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getHost

String ql(str);

(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

jEnv->ReleaseStringUTFChars(jQl,str);

(JNIEnv *jEnv, jobject jThs, jint jNs) {

_nameSpace *cNs=(_nameSpace*)jNs;

const String &ns=cNs->nameSpace_;

jstring str=jEnv->NewStringUTF(ns.getCString());

return str;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setHost

try {

(JNIEnv *jEnv, jobject jThs, jint jNs, jstring jHn) {

checkNs(cop,jNs);

_nameSpace *cNs=(_nameSpace*)jNs;

Array<CIMObject> enm=cCc->execQuery(cop->getNameSpace(),ql,query);

const char *str=jEnv->GetStringUTFChars(jHn,NULL);

Array<CIMInstance> *enmInst=new Array<CIMInstance>();

cNs->port_=0;

for (int i=0,m=enm.size(); i<m; i++) {

cNs->hostName_=str;

enmInst->append(CIMInstance(enm[i]));

jEnv->ReleaseStringUTFChars(jHn,str);

}

return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);

}

Catch(jEnv);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setNameSpace

return 0;

(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);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associatorNames

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,

jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL);

CIMName assocClass(str);

// -------------------------------------

jEnv->ReleaseStringUTFChars(jAssocClass,str);

// ---

str=jEnv->GetStringUTFChars(jResultClass,NULL);

// - Enumerators

// ---

// -------------------------------------

CIMName resultClass(str);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1getInstance

jEnv->ReleaseStringUTFChars(jResultClass,str);

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) {

str=jEnv->GetStringUTFChars(jRole,NULL);

Array<CIMInstance> *enm=(Array<CIMInstance>*)jEnum;

return (jint) new CIMInstance((*enm)[pos]);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1size

String role(str);

(JNIEnv *jEnv, jobject jThs, jint jEnum) {

Array<CIMInstance> *enm=(Array<CIMInstance>*)jEnum;

return enm->size();

}

jEnv->ReleaseStringUTFChars(jRole,str);

str=jEnv->GetStringUTFChars(jResultRole,NULL);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1getObjectPath

String resultRole(str);

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) {

Array<CIMObjectPath> *enm=(Array<CIMObjectPath>*)jEnum;

jEnv->ReleaseStringUTFChars(jResultRole,str);

return (jint) new CIMObjectPath((*enm)[pos]);

try {

checkNs(cop,jNs);

Array<CIMObjectPath> enm=cCc->associatorNames(

cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole);

return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm));

}

Catch(jEnv);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1size

return 0;

(JNIEnv *jEnv, jobject jThs, jint jEnum) {

Array<CIMObjectPath> *enm=(Array<CIMObjectPath>*)jEnum;

return enm->size();

}

// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associators

// ---

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,

// - CIMClient

jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole,

// ---

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)

// -------------------------------------

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMPropertyList pl = getList(jEnv,jPl);

const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL);

CIMName assocClass(str);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1newNaUnPw

jEnv->ReleaseStringUTFChars(jAssocClass,str);

(JNIEnv *jEnv, jobject jThs, jint jNs, jstring jUn, jstring jPw) {

str=jEnv->GetStringUTFChars(jResultClass,NULL);

_nameSpace *cNs=(_nameSpace*)jNs;

const char *un=jEnv->GetStringUTFChars(jUn,NULL);

CIMName resultClass(str);

const char *pw=jEnv->GetStringUTFChars(jPw,NULL);

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 {

CIMClient *cc=new CIMClient();

checkNs(cop,jNs);

cc->connect(cNs->hostName(),cNs->port(),un,pw);

Array<CIMObject> enm=cCc->associators(

jEnv->ReleaseStringUTFChars(jUn,un);

cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole,

jEnv->ReleaseStringUTFChars(jPw,pw);

(Boolean)includeQualifiers,(Boolean)includeClassOrigin,pl);

cout<<"### connect ok "<<(jint)(void*)cc<<endl;

Array<CIMInstance> *enmInst=new Array<CIMInstance>();

return (jint)(void*)cc;

for (int i=0,m=enm.size(); i<m; i++) {

}

enmInst->append(CIMInstance(enm[i]));

catch (CIMException e) {

jEnv->ReleaseStringUTFChars(jUn,un);

jEnv->ReleaseStringUTFChars(jPw,pw);

throwCimException(jEnv,e);

}

catch (...) {

return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);

jEnv->ReleaseStringUTFChars(jUn,un);

jEnv->ReleaseStringUTFChars(jPw,pw);

throwFailedException(jEnv);

}

Catch(jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1disconnect

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1referenceNames

(JNIEnv *jEnv, jobject jThs, jint jCc) {

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,

CIMClient *cCc=(CIMClient*)jCc;

jstring jAssocClass, jstring jRole)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL);

CIMName assocClass(str);

jEnv->ReleaseStringUTFChars(jAssocClass,str);

str=jEnv->GetStringUTFChars(jRole,NULL);

String role(str);

jEnv->ReleaseStringUTFChars(jRole,str);

try {

cCc->disconnect();

checkNs(cop,jNs);

}

Array<CIMObjectPath> enm=cCc->referenceNames(

catch (CIMException e) {

cop->getNameSpace(),*cop,assocClass,role);

throwCimException(jEnv,e);

return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath>(enm));

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getClass

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1references

(JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jboolean lo) {

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,

CIMClient *cCc=(CIMClient*)jCc;

jstring jAssocClass, jstring jRole,

CIMObjectPath *cop=(CIMObjectPath*)jCop;

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

CIMPropertyList pl = getList(jEnv,jPl);

const char *str = jEnv->GetStringUTFChars(jAssocClass,NULL);

CIMName assocClass(str);

jEnv->ReleaseStringUTFChars(jAssocClass,str);

str=jEnv->GetStringUTFChars(jRole,NULL);

String role(str);

jEnv->ReleaseStringUTFChars(jRole,str);

try {

CIMClass cls=cCc->getClass(cop->getNameSpace(),cop->getClassName(),(Boolean)lo);

checkNs(cop,jNs);

return (jint) new CIMClass(cls);

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]));

}

catch (CIMException e) {

return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);

throwCimException(jEnv,e);

}

Catch(jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteClass

static int normalizeNs(String &ns, String &nsBase, String &lastNsComp) {

(JNIEnv *jEnv, jobject jThs, jint jCc, int jCop) {

Uint32 n=ns.size();

CIMClient *cCc=(CIMClient*)jCc;

if (ns[n-1]=='/') {

CIMObjectPath *cop=(CIMObjectPath*)jCop;

if (n>=2) ns=ns.subString(0,n-2);

try {

cCc->deleteClass(cop->getNameSpace(),cop->getClassName());

}

catch (CIMException e) {

throwCimException(jEnv,e);

lastNsComp=ns;

nsBase="root";

n=ns.reverseFind('/');

if (n!=PEG_NOT_FOUND) {

lastNsComp=ns.subString(n+1);

nsBase=ns.subString(0,n);

}

return;

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createClass

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createNameSpace

(JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, int jCl) {

(JNIEnv *jEnv, jobject jThs, jint jCc, jstring jNs)

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMClass *cl=(CIMClass*)jCl;

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->createClass(cop->getNameSpace(),*cl);

cCc->createInstance(CIMNamespaceName(nsBase),newInstance);

}

catch (CIMException e) {

Catch(jEnv);

throwCimException(jEnv,e);

}

return;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setClass

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateNameSpaces

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jint jCl) {

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jboolean deep, jobject jVec)

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

JMPIjvm::cacheIDs(jEnv);

CIMClass *cl=(CIMClass*)jCl;

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

String ns = cop->getNameSpace().getString();

try {

cCc->modifyClass(cop->getNameSpace(),*cl);

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 (CIMException e) {

throwCimException(jEnv,e);

}

return ;

Catch(jEnv);

return jVec;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClasses

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteNameSpace

(JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jboolean deep, jboolean lo) {

(JNIEnv *jEnv, jobject jThs, jint jCc, jstring jNs)

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, 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 {

Array<CIMClass> enm=cCc->enumerateClasses(

cCc->deleteInstance(CIMNamespaceName(nsBase),cop);

cop->getNameSpace(),cop->getClassName(),(Boolean)deep,(Boolean)lo);

return (jint) new Array<CIMClass>(enm);

}

catch (CIMException e) {

Catch(jEnv);

throwCimException(jEnv,e);

}

return 0;

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1finalize

(JNIEnv *jEnv, jobject jThs, jint jCc)

{

CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

delete cCc;

DEBUG_ConvertCleanup (jint, jCc);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClassNames

// -------------------------------------

(JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jboolean deep) {

// ---

CIMClient *cCc=(CIMClient*)jCc;

// - CIMObject

CIMObjectPath *cop=(CIMObjectPath*)jCop;

// ---

CIMNamespaceName ns=cop->getNameSpace();

// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObject__1newClass

(JNIEnv *jEnv, jobject jThs, jint jCc)

{

CIMClass *cCc = DEBUG_ConvertJavaToC (jint, CIMClass*, jCc);

try {

Array<CIMName> enm=cCc->enumerateClassNames(

CIMObject *cCo = new CIMObject (*cCc);

ns,cop->getClassName(),(Boolean)deep);

Array<CIMObjectPath> *enmop=new Array<CIMObjectPath>();

return DEBUG_ConvertCToJava (CIMObject*, jint, cCo);

for (int i=0,m=enm.size(); i<m; i++) {

enmop->append(CIMObjectPath(String::EMPTY,ns,enm[i]));

}

return (jint)enmop;

}

catch (CIMException e) {

throwCimException(jEnv,e);

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObject__1newInstance

(JNIEnv *jEnv, jobject jThs, jint jCi)

{

CIMInstance *cCi = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getInstance

(JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jboolean lo) {

CIMClient *cCc=(CIMClient*)jCc;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

try {

CIMInstance inst=cCc->getInstance(cop->getNameSpace(),*cop,(Boolean)lo);

CIMObject *cCo = new CIMObject (*cCi);

return (jint) new CIMInstance(inst);

}

return DEBUG_ConvertCToJava (CIMObject*, jint, cCo);

catch (CIMException e) {

throwCimException(jEnv,e);

}

Catch(jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteInstance

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObject__1finalize

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop) {

(JNIEnv *jEnv, jobject jThs, jint jInst)

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMObject *co = DEBUG_ConvertJavaToC (jint, CIMObject*, jInst);

try {

cCc->deleteInstance(cop->getNameSpace(),*cop);

delete co;

}

catch (CIMException e) {

DEBUG_ConvertCleanup (jint, jInst);

throwCimException(jEnv,e);

}

return;

// -------------------------------------

// ---

// - OperationContext

// ---

// -------------------------------------

* Class: OperationContext

* Method: _get

* Signature: (ILjava/lang/String;Ljava/lang/String;)Ljava/lang/Object;

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_OperationContext__1get

(JNIEnv *jEnv, jobject jThs, jint jInst, jstring jContainer, jstring jKey)

{

OperationContext *poc = DEBUG_ConvertJavaToC (jint, OperationContext*, jInst);

jobject jRet = 0;

if (!poc)

{

return jRet;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1createInstance

const char *pszContainer = jEnv->GetStringUTFChars (jContainer, NULL);

(JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, int jCi) {

const char *pszKey = jEnv->GetStringUTFChars (jKey, NULL);

CIMClient *cCc=(CIMClient*)jCc;

String container (pszContainer);

CIMObjectPath *cop=(CIMObjectPath*)jCop;

String key (pszKey);

CIMInstance *ci=(CIMInstance*)jCi;

///printf ("container: %s\n", pszContainer);

///printf ("key: %s\n", pszKey);

try {

CIMObjectPath obj=cCc->createInstance(cop->getNameSpace(),*ci);

if (container == "IdentityContainer")

return (jint) new CIMObjectPath(obj);

{

}

IdentityContainer ic = poc->get (IdentityContainer::NAME);

catch (CIMException e) {

throwCimException(jEnv,e);

/////////printf ("ic\n");

if (key == "userName")

{

String userName = ic.getUserName ();

////////////printf ("userName: %s\n", (const char*)userName.getCString ());

jRet = jEnv->NewStringUTF ((const char*)userName.getCString ());

}

return 0;

}

else if (container == "SubscriptionInstanceContainer")

{

SubscriptionInstanceContainer sic = poc->get (SubscriptionInstanceContainer::NAME);

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setInstance

if (key == "subscriptionInstance")

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jint jCi) {

{

CIMClient *cCc=(CIMClient*)jCc;

CIMInstance ci = sic.getInstance ();

CIMObjectPath *cop=(CIMObjectPath*)jCop;

jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance (ci));

CIMInstance *ci=(CIMInstance*)jCi;

try {

jRet = jEnv->NewObject (JMPIjvm::jv.CIMInstanceClassRef,

cCc->modifyInstance(cop->getNameSpace(),*ci);

JMPIjvm::jv.CIMInstanceNewI,

}

jciRef);

catch (CIMException e) {

throwCimException(jEnv,e);

}

return ;

}

else if (container == "SubscriptionInstanceNamesContainer")

{

SubscriptionInstanceNamesContainer sinc = poc->get (SubscriptionInstanceNamesContainer::NAME);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstances

if (key == "subscriptionInstanceNames")

(JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jboolean deep, jboolean lo) {

{

CIMClient *cCc=(CIMClient*)jCc;

Array<CIMObjectPath> copa = sinc.getInstanceNames ();

CIMObjectPath *cop=(CIMObjectPath*)jCop;

jobjectArray jcopa = 0;

try {

int jcopaLength = copa.size ();

Array<CIMInstance> enm=cCc->enumerateInstances(

cop->getNameSpace(),cop->getClassName(),(Boolean)deep,(Boolean)lo);

jcopa = jEnv->NewObjectArray (jcopaLength,

return (jint) new Array<CIMInstance>(enm);

JMPIjvm::jv.CIMObjectPathClassRef,

0);

for (int i = 0; i < jcopaLength; i++)

{

jEnv->SetObjectArrayElement (jcopa,

jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef,

JMPIjvm::jv.CIMObjectPathNewI,

new CIMObjectPath (copa[i])));

}

catch (CIMException e) {

throwCimException(jEnv,e);

jRet = (jobject)jcopa;

}

return 0;

}

else if (container == "SubscriptionFilterConditionContainer")

{

SubscriptionFilterConditionContainer sfcc = poc->get (SubscriptionFilterConditionContainer::NAME);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstanceNames

/////////printf ("sfcc\n");

(JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jboolean deep) {

CIMClient *cCc=(CIMClient*)jCc;

if (key == "filterCondition")

CIMObjectPath *cop=(CIMObjectPath*)jCop;

{

try {

String filterCondition = sfcc.getFilterCondition ();

Array<CIMObjectPath> enm=cCc->enumerateInstanceNames(

cop->getNameSpace(),cop->getClassName()); //,(Boolean)deep);

////////////printf ("filterCondition: %s\n", (const char*)filterCondition.getCString ());

return (jint) new Array<CIMObjectPath>(enm);

jRet = jEnv->NewStringUTF ((const char*)filterCondition.getCString ());

}

catch (CIMException e) {

else if (key == "queryLanguage")

throwCimException(jEnv,e);

{

String queryLanguage = sfcc.getQueryLanguage ();

jRet = jEnv->NewStringUTF ((const char*)queryLanguage.getCString ());

}

return 0;

}

else if (container == "SubscriptionFilterQueryContainer")

{

SubscriptionFilterQueryContainer sfqc = poc->get (SubscriptionFilterQueryContainer::NAME);

if (key == "filterQuery")

{

String filterQuery = sfqc.getFilterQuery ();

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty

jRet = jEnv->NewStringUTF ((const char*)filterQuery.getCString ());

(JNIEnv *jEnv, jobject jThs, jint jCc, int 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 {

CIMValue *val=new CIMValue(cCc->getProperty(cop->getNameSpace(),*cop,pName));

return (jint)val;

}

catch (CIMException e) {

throwCimException(jEnv,e);

}

return 0;

}

else if (key == "queryLanguage")

{

String queryLanguage = sfqc.getQueryLanguage ();

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty

jRet = jEnv->NewStringUTF ((const char*)queryLanguage.getCString ());

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jstring jPn, jint jV) {

CIMClient *cCc=(CIMClient*)jCc;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

CIMValue *val=(CIMValue*)jCop;

const char *str=jEnv->GetStringUTFChars(jPn,NULL);

CIMName pName(str);

jEnv->ReleaseStringUTFChars(jPn,str);

try {

cCc->setProperty(cop->getNameSpace(),*cop,pName,*val);

}

catch (CIMException e) {

else if (key == "sourceNameSpace")

throwCimException(jEnv,e);

{

CIMNamespaceName cimNameSpaceName = sfqc.getSourceNameSpace ();

String nameSpaceName = cimNameSpaceName.getString ();

jRet = jEnv->NewStringUTF ((const char*)nameSpaceName.getCString ());

}

return;

}

else if (container == "SnmpTrapOidContainer")

{

SnmpTrapOidContainer stoc = poc->get (SnmpTrapOidContainer::NAME);

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod

if (key == "snmpTrapOid")

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jstring jMn, jobject jIn, jobject jOut) {

{

CIMClient *cCc=(CIMClient*)jCc;

String snmpTrapOid = stoc.getSnmpTrapOid ();

CIMObjectPath *cop=(CIMObjectPath*)jCop;

const char *str=jEnv->GetStringUTFChars(jMn,NULL);

CIMName method(str);

jEnv->ReleaseStringUTFChars(jMn,str);

Array<CIMParamValue> in;

Array<CIMParamValue> out;

for (int i=0,m=jEnv->CallIntMethod(jIn,JMPIjvm::jv.VectorSize); i<m; i++) {

JMPIjvm::checkException(jEnv);

jobject jProp=jEnv->CallObjectMethod(jIn,JMPIjvm::jv.VectorElementAt,i);

JMPIjvm::checkException(jEnv);

CIMProperty *p=((CIMProperty*)jEnv->CallIntMethod(jProp,JMPIjvm::jv.PropertyCInst));

JMPIjvm::checkException(jEnv);

in.append(CIMParamValue(p->getName().getString(),p->getValue()));

}

try {

CIMValue *val=new CIMValue(cCc->invokeMethod(cop->getNameSpace(),*cop,method,in,out));

return (jint)val;

for (int i=0,m=out.size(); i<m; i++) {

jRet = jEnv->NewStringUTF ((const char*)snmpTrapOid.getCString ());

const CIMParamValue & parm=out[i];

const CIMValue v=parm.getValue();

CIMProperty *p=new CIMProperty(parm.getParameterName(),v,v.getArraySize());

jobject prop=jEnv->NewObject(JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,(jint)p);

jEnv->CallVoidMethod(jOut,JMPIjvm::jv.VectorAddElement,prop);

}

catch (CIMException e) {

throwCimException(jEnv,e);

}

return 0;

Catch(jEnv);

///printf ("jRet: %08X\n", (int)jRet);

jEnv->ReleaseStringUTFChars (jContainer, pszContainer);

jEnv->ReleaseStringUTFChars (jKey, pszKey);

return jRet;

}

// -------------------------------------

// ---

// - SelectExp

// ---

// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery

(JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jstring jQuery, jstring jQl) {

* Class: org_pegasus_jmpi_SelectExp

CIMClient *cCc=(CIMClient*)jCc;

* Method: _finalize

CIMObjectPath *cop=(CIMObjectPath*)jCop;

* Signature: (I)V

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_SelectExp__1finalize

(JNIEnv *jEnv, jobject jThs, jint jEselx)

{

CMPI_SelectExp *eSelx = DEBUG_ConvertJavaToC (jint, CMPI_SelectExp*, jEselx);

const char *str=jEnv->GetStringUTFChars(jQuery,NULL);

delete eSelx;

String query(str);

jEnv->ReleaseStringUTFChars(jQuery,str);

str=jEnv->GetStringUTFChars(jQl,NULL);

String ql(str);

jEnv->ReleaseStringUTFChars(jQl,str);

try {

DEBUG_ConvertCleanup (jint, jEselx);

Array<CIMObject> enm=cCc->execQuery(

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;

}

catch (CIMException e) {

throwCimException(jEnv,e);

}

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associatorNames

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop,

* Class: org_pegasus_jmpi_SelectExp

jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole) {

* Method: _newSelectExp

CIMClient *cCc=(CIMClient*)jCc;

* Signature: (Ljava/lang/String;)I

CIMObjectPath *cop=(CIMObjectPath*)jCop;

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_SelectExp__1newSelectExp

(JNIEnv *jEnv, jobject jThs, jstring jQuery)

{

const char *pszQuery = jEnv->GetStringUTFChars (jQuery, NULL);

CMPI_SelectExp *eSelx = NULL;

WQLSelectStatement *stmt = NULL;

String queryLanguage (CALL_SIGN_WQL);

String query (pszQuery);

const char *str=jEnv->GetStringUTFChars(jAssocClass,NULL);

stmt = new WQLSelectStatement (queryLanguage, query);

CIMName assocClass(str);

eSelx = new CMPI_SelectExp (stmt);

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 {

jEnv->ReleaseStringUTFChars (jQuery, pszQuery);

Array<CIMObjectPath> enm=cCc->associatorNames(

cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole);

return DEBUG_ConvertCToJava (CMPI_SelectExp *, jint, eSelx);

return (jint) new Array<CIMObjectPath>(enm);

}

catch (CIMException e) {

throwCimException(jEnv,e);

* Class: org_pegasus_jmpi_SelectExp

* Method: _getSelectString

* Signature: (I)Ljava/lang/String;

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_SelectExp__1getSelectString

(JNIEnv *jEnv, jobject jThs, jint jEselx)

{

CMPI_SelectExp *eSelx = DEBUG_ConvertJavaToC (jint, CMPI_SelectExp*, jEselx);

return (jstring)jEnv->NewStringUTF (eSelx->cond.getCString ());

}

// -------------------------------------

// ---

// - JMPISelectList

// ---

// -------------------------------------

* Class: org_pegasus_jmpi_JMPISelectList

* Method: _applyInstance

* Signature: (II)I

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyInstance

(JNIEnv *jEnv, jobject jThs, jint jEselx, jint jciInstance)

{

CMPI_SelectExp *eSelx = DEBUG_ConvertJavaToC (jint, CMPI_SelectExp*, jEselx);

CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciInstance);

CIMInstance *ciRet = 0;

if ( !eSelx

|| !eSelx->wql_stmt

)

{

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associators

ciRet = new CIMInstance (ci->clone ());

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop,

jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole,

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray propertyList) {

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 {

if (ciRet)

Array<CIMObject> enm=cCc->associators(

{

cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole,

eSelx->wql_stmt->applyProjection (*ciRet, false);

(Boolean)includeQualifiers,(Boolean)includeClassOrigin,CIMPropertyList());

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 (CIMException e) {

throwCimException(jEnv,e);

return DEBUG_ConvertCToJava (CIMInstance *, jint, ciRet);

}

* Class: org_pegasus_jmpi_JMPISelectList

* Method: _applyClass

* Signature: (II)I

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyClass

(JNIEnv *jEnv, jobject jThs, jint jEselx, jint jciClass)

{

CMPI_SelectExp *eSelx = DEBUG_ConvertJavaToC (jint, CMPI_SelectExp*, jEselx);

CIMClass *cc = DEBUG_ConvertJavaToC (jint, CIMClass*, jciClass);

CIMClass *ccRet = NULL;

if ( !eSelx

|| !eSelx->wql_stmt

)

{

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1referenceNames

if (cc)

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop,

{

jstring jAssocClass, jstring jRole) {

CIMObject co (cc->clone ());

CIMClient *cCc=(CIMClient*)jCc;

CIMObjectPath *cop=(CIMObjectPath*)jCop;

const char *str=jEnv->GetStringUTFChars(jAssocClass,NULL);

eSelx->wql_stmt->applyProjection (co, false);

CIMName assocClass(str);

jEnv->ReleaseStringUTFChars(jAssocClass,str);

str=jEnv->GetStringUTFChars(jRole,NULL);

String role(str);

jEnv->ReleaseStringUTFChars(jRole,str);

try {

ccRet = new CIMClass (co);

Array<CIMObjectPath> enm=cCc->referenceNames(

cop->getNameSpace(),*cop,assocClass,role);

return DEBUG_ConvertCToJava (CIMClass *, jint, ccRet);

return (jint) new Array<CIMObjectPath>(enm);

}

catch (CIMException e) {

throwCimException(jEnv,e);

}

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1references

// -------------------------------------

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop,

// ---

jstring jAssocClass, jstring jRole,

// - JMPIQueryExp

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray propertyList) {

// ---

CIMClient *cCc=(CIMClient*)jCc;

// -------------------------------------

CIMObjectPath *cop=(CIMObjectPath*)jCop;

const char *str=jEnv->GetStringUTFChars(jAssocClass,NULL);

CIMName assocClass(str);

* Class: org_pegasus_jmpi_JMPIQueryExp

jEnv->ReleaseStringUTFChars(jAssocClass,str);

* Method: _applyInstance

str=jEnv->GetStringUTFChars(jRole,NULL);

* Signature: (II)Z

String role(str);

jEnv->ReleaseStringUTFChars(jRole,str);

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_JMPIQueryExp__1applyInstance

(JNIEnv *jEnv, jobject jThs, jint jEselx, jint jciInstance)

{

CMPI_SelectExp *eSelx = DEBUG_ConvertJavaToC (jint, CMPI_SelectExp*, jEselx);

CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciInstance);

try {

if ( !eSelx

Array<CIMObject> enm=cCc->references(

|| !eSelx->wql_stmt

cop->getNameSpace(),*cop,assocClass,role,

)

(Boolean)includeQualifiers,(Boolean)includeClassOrigin,CIMPropertyList());

{

Array<CIMInstance> *enmInst=new Array<CIMInstance>();

return 0;

for (int i=0,m=enm.size(); i<m; i++) {

enmInst->append(CIMInstance(enm[i]));

}

return (jint)enmInst;

}

catch (CIMException e) {

throwCimException(jEnv,e);

if (eSelx->wql_stmt)

{

return eSelx->wql_stmt->evaluate (*ci);

}

return 0;

return false;

}

} // extern "C"

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.3
changed lines
	Added in v.1.35.2.2

No CVS admin address has been configured