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.32 and 1.44

version 1.32, 2005/12/08 21:34:54

version 1.44, 2006/06/09 19:04:44

Line 1

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

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

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

Line 8

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

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

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

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

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

Line 37

Line 39

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

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

#include "JMPIImpl.h"

#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)

Line 55

#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/WQL/WQLSelectStatement.h>

#include <Pegasus/WQL/WQLParser.h>

#define CALL_SIGN_WQL "WQL"

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

Line 111

Line 113

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

Line 160

Line 166

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

Line 210

Line 222

int JMPIjvm::cacheIDs(JNIEnv *env)

{

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

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(classNames[0])); i++) {

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

{

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

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

{

Line 229

Line 242

}

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

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

{

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

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

instanceMethodNames[j].methodName,

Line 240

Line 254

}

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

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

{

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

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

staticMethodNames[k].methodName,

Line 276

Line 291

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

#ifdef JAVA_DESTROY_VM_WORKS

if (jvm!=NULL) {

if (jvm!= NULL)

{

JvmVector *jv;

attachThread(&jv);

Line 325

Line 341

std::ostringstream oss;

#ifdef PEGASUS_DEBUG

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

if (getenv("PEGASUS_JMPI_TRACE"))

else JMPIjvm::trace=0;

JMPIjvm::trace = 1;

else

JMPIjvm::trace = 0;

#else

JMPIjvm::trace=0;

#endif

Line 336

Line 354

jv.initRc=0;

envstring=getenv("CLASSPATH");

if (envstring==NULL) {

if (envstring == NULL)

{

jv.initRc=1;

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

Line 433

Line 452

free (poptions);

}

if (res!=0) {

if (res!= 0)

{

jv.initRc=1;

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

Line 443

Line 463

cacheIDs(env);

if (env->ExceptionOccurred()) {

if (env->ExceptionOccurred())

{

jv.initRc=1;

env->ExceptionDescribe();

Line 504

Line 525

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

if (gProv)

{

*cls=scls;

return gProv;

}

Line 516

Line 538

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

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

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

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

jjar,jcln);

jv.JarClassLoaderLoad,

if (env->ExceptionCheck()) {

jjar,

jcln);

if (env->ExceptionCheck())

{

env->ExceptionDescribe();

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

////////return NULL;

Line 526

Line 551

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

if (env->ExceptionCheck()) {

if (env->ExceptionCheck())

{

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

DDD(env->ExceptionDescribe());

Line 543

Line 569

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

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

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

if (env->ExceptionCheck()) {

if (env->ExceptionCheck())

{

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

return NULL;

}

Line 569

Line 596

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

if (gProv)

{

*cls=scls;

return gProv;

}

scls=getGlobalClassRef(env,cn);

if (env->ExceptionCheck()) {

if (env->ExceptionCheck())

{

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

DDD(env->ExceptionDescribe());

Line 592

Line 621

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

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

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

if (env->ExceptionCheck()) {

if (env->ExceptionCheck())

{

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

return NULL;

}

Line 608

Line 638

void JMPIjvm::checkException(JNIEnv *env)

{

if (env->ExceptionCheck()) {

if (env->ExceptionCheck ())

jstring jMsg=NULL,jId=NULL;

{

jstring jMsg = NULL,

jId = NULL;

int code;

const char *cp;

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

String msg = String::EMPTY,

id = String::EMPTY;

jthrowable err=env->ExceptionOccurred();

DDD(env->ExceptionDescribe());

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

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

{

env->ExceptionClear();

if (err) {

if (err)

{

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

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

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

if (jId) {

if (jId)

{

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

id=String(cp);

env->ReleaseStringUTFChars(jId,cp);

}

if (jMsg) {

if (jMsg)

{

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

msg=String(cp);

env->ReleaseStringUTFChars(jMsg,cp);

Line 639

Line 678

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

}

else {

else

{

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

env->ExceptionDescribe();

exit(13);

Line 664

Line 704

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

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

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

if (ary != 0) {

if (ary != 0)

{

jstring str = 0;

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

(*env).SetByteArrayRegion (ary,

(jsize)len,

(jbyte *)s);

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

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

{

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

}

(*env).DeleteLocalRef(ary);

return str;

}

return 0;

}

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

* name - NewPlatformStringArray

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

Line 696

Line 741

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

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

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

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

{

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

NULL_CHECK0(str);

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

(*env).DeleteLocalRef(str);

}

return (jobjectArray)ary;

}

CIMPropertyList getList(JNIEnv *jEnv, jobjectArray l)

{

CIMPropertyList pl;

if (l)

{

Array<CIMName> n;

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

{

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

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

n.append (pn);

jEnv->ReleaseStringUTFChars (jObj, pn);

}

pl.set (n);

}

extern "C" {

return pl;

}

extern "C" {

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

void throwCimException (JNIEnv *jEnv, CIMException &e)

{

JMPIjvm::cacheIDs(jEnv);

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

jEnv->Throw((jthrowable)ev);

}

void throwFailedException(JNIEnv *jEnv) {

void throwFailedException (JNIEnv *jEnv)

{

JMPIjvm::cacheIDs(jEnv);

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

jEnv->Throw((jthrowable)ev);

}

void throwNotSupportedException(JNIEnv *jEnv) {

void throwNotSupportedException (JNIEnv *jEnv)

{

JMPIjvm::cacheIDs(jEnv);

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

jEnv->Throw((jthrowable)ev);

}

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

// ---

// - CIMException

Line 740

Line 811

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

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1new

(JNIEnv *jEnv, jobject jThs) {

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

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

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

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

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

}

Line 777

Line 853

// ---

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

CIMPropertyList getList(JNIEnv *jEnv, jobjectArray l) {

CIMPropertyList pl;

if (l) {

Array<CIMName> n;

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

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

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

n.append(pn);

jEnv->ReleaseStringUTFChars(jObj,pn);

}

pl.set(n);

}

return pl;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getClass

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

jboolean iq, jboolean ic, jobjectArray jPl)

Line 813

Line 868

pl=CIMPropertyList();

try {

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

CIMClass cls = ch->getClass (ctx,

cop->getNameSpace (),

cop->getClassName(),

(Boolean)lo,

(Boolean)iq,

Line 836

Line 892

OperationContext ctx;

try {

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

ch->createClass (ctx,

cop->getNameSpace (),

*cl);

}

Catch(jEnv);

}

Line 850

Line 908

OperationContext ctx;

try {

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

ch->modifyClass (ctx,

cop->getNameSpace (),

*cl);

}

Catch(jEnv);

}

Line 863

Line 923

OperationContext ctx;

try {

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

ch->deleteClass (ctx,

cop->getNameSpace (),

cop->getClassName ());

}

Catch(jEnv);

}

Line 877

Line 939

OperationContext ctx;

try {

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

Array<CIMName> enm = ch->enumerateClassNames (ctx,

cop->getNameSpace (),

cop->getClassName (),

(Boolean)deep);

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

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

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

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

{

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

ns,

enm[i]));

}

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

Line 903

Line 971

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

cop->getNameSpace(),

cop->getClassName(),

deep,

(Boolean)deep,

(Boolean)lo,

iq,

(Boolean)iq,

ic);

(Boolean)ic);

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

}

Line 937

Line 1005

(Boolean)iq,

(Boolean)ic,

pl));

return DEBUG_ConvertCToJava (CIMInstance*, jint, inst);

}

Catch(jEnv);

Line 968

Line 1037

try {

ci->setPath(*cop);

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

CIMObjectPath obj = ch->createInstance (ctx,

cop->getNameSpace (),

*ci);

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

}

Line 989

Line 1060

try {

ci->setPath(*cop);

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

ch->modifyInstance (ctx,

cop->getNameSpace (),

*ci,

(Boolean)iq,

pl);

}

Catch(jEnv);

}

Line 1030

Line 1105

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

cop->getNameSpace(),

cop->getClassName(),

deep,

(Boolean)deep,

lo,

(Boolean)lo,

iq,

(Boolean)iq,

ic,

(Boolean)ic,

pl);

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

}

Catch(jEnv);

Line 1060

Line 1136

jEnv->ReleaseStringUTFChars(jQl,str);

try {

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

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

cop->getNameSpace (),

ql,

query);

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

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

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

{

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

}

Line 1087

Line 1167

jEnv->ReleaseStringUTFChars(jN,str);

try {

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

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

cop->getNameSpace (),

*cop,

prop));

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

Line 1109

Line 1192

jEnv->ReleaseStringUTFChars(jPn,str);

try {

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

ch->setProperty (ctx,

cop->getNameSpace (),

*cop,

pName,

*val);

}

Catch(jEnv);

}

Line 1130

Line 1217

Array<CIMParamValue> in;

Array<CIMParamValue> out;

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

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

{

JMPIjvm::checkException(jEnv);

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

Line 1145

Line 1233

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

}

try {

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

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

cop->getNameSpace (),

*cop,

method,

in,

out));

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

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

{

const CIMParamValue &parm = out[i];

const CIMValue v = parm.getValue();

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

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

v.getArraySize ());

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

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

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

JMPIjvm::jv.CIMPropertyNewI,

jp);

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

}

Line 1166

Line 1264

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod24

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

jobjectArray jIn, jobjectArray jOut)

{

JMPIjvm::cacheIDs(jEnv);

Line 1180

Line 1279

Array<CIMParamValue> in;

Array<CIMParamValue> out;

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

if (jIn)

{

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

{

JMPIjvm::checkException(jEnv);

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

JMPIjvm::checkException(jEnv);

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

Line 1193

Line 1296

in.append(*p);

}

try {

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

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

cop->getNameSpace (),

*cop,

method,

in,

out));

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

if (jOut)

{

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

{

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

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

jEnv->SetObjectArrayElement(jOut,i,

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

}

return DEBUG_ConvertCToJava (CIMValue*, jint, val);

}

Catch(jEnv);

Line 1218

Line 1331

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

OperationContext ctx;

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

CIMName assocClass(str);

CIMName assocClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

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

jEnv->Throw ((jthrowable)ev);

return 0;

}

jEnv->ReleaseStringUTFChars(jAssocClass,str);

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

CIMName resultClass(str);

CIMName resultClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

resultClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

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

jEnv->Throw ((jthrowable)ev);

return 0;

}

jEnv->ReleaseStringUTFChars(jResultClass,str);

Line 1266

Line 1422

OperationContext ctx;

CIMPropertyList pl = getList(jEnv,jPl);

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

CIMName assocClass(str);

CIMName assocClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

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

jEnv->Throw ((jthrowable)ev);

return 0;

}

jEnv->ReleaseStringUTFChars(jAssocClass,str);

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

CIMName resultClass(str);

CIMName resultClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

resultClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

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

jEnv->Throw ((jthrowable)ev);

return 0;

}

jEnv->ReleaseStringUTFChars(jResultClass,str);

Line 1301

Line 1499

pl);

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

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

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

{

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

}

Line 1320

Line 1519

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

OperationContext ctx;

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

CIMName assocClass(str);

CIMName assocClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

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

jEnv->Throw ((jthrowable)ev);

return 0;

}

jEnv->ReleaseStringUTFChars(jAssocClass,str);

Line 1354

Line 1574

OperationContext ctx;

CIMPropertyList pl = getList(jEnv,jPl);

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

CIMName assocClass(str);

CIMName assocClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

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

jEnv->Throw ((jthrowable)ev);

return 0;

}

jEnv->ReleaseStringUTFChars(jAssocClass,str);

Line 1375

Line 1616

pl);

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

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

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

{

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

}

Line 1402

Line 1644

jEnv->ReleaseStringUTFChars(jNs,str);

CIMObjectPath ref(CIMObjectPath(ind->getPath()));

CIMObjectPath ref (ind->getPath ());

ref.setNameSpace(ns);

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

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

ind->setPath(ref);

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

JMPIProviderManager::indProvRecord *prec;

JMPIProviderManager::indProvRecord *prec = NULL;

OperationContext* context;

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

OperationContext *context = NULL;

bool fResult = false;

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

{

if (prec->enabled) {

AutoMutex lock (JMPIProviderManager::mutexProvTab);

context=prec->ctx;

try {

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

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

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

}

if (fResult)

{

if (prec->enabled)

{

try

{

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

}

Catch(jEnv);

}

else {

else

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

{

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

}

Line 1448

Line 1706

try {

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

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

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

{

try {

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

}

catch (Exception e) {}

}

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

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

{

CIMProperty cp = cls->getProperty(i);

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

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

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

{

try {

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

}

Line 1541

Line 1802

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

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

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

{

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

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

Line 1569

Line 1831

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

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

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

{

cls->removeProperty(i);

}

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

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

{

JMPIjvm::checkException(jEnv);

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

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

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

Line 1586

Line 1849

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifiers

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

{

Line 1594

Line 1856

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

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

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

{

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

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

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

Line 1634

Line 1897

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

if (cls->hasKeys()) {

if (cls->hasKeys ())

{

Array<CIMName> keyNames;

cls->getKeyNames(keyNames);

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

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

{

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

if (pos!=PEG_NOT_FOUND){

if (pos!= PEG_NOT_FOUND)

{

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

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

Line 1661

Line 1927

jint rv = -1;

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

if (pos!=PEG_NOT_FOUND) {

if (pos!= PEG_NOT_FOUND)

{

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

}

Line 1696

Line 1963

CIMClass *cf = 0;

CIMName clsn = cc->getClassName();

if (lo) {

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

{

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

cf->removeProperty (i);

}

return DEBUG_ConvertCToJava (CIMClass*, jint, cf);

}

else if (jPl) {

else if (jPl)

{

CIMPropertyList pl = getList(jEnv,jPl);

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

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

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

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

{

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

if (pos!=PEG_NOT_FOUND) {

if (pos!= PEG_NOT_FOUND)

if (iq) {

{

if (iq)

{

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

if (!ic)

Line 1724

Line 1999

cf->addProperty(cp);

}

else {

else

{

CIMProperty cp = cc->getProperty(pos);

CIMName co;

Line 1743

Line 2019

}

if (iq)

{

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

{

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

}

else if (iq) {

}

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

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

{

CIMProperty cp=cf->getProperty(i);

cp.setClassOrigin(CIMName());

Line 1760

Line 2042

cf->addProperty(cp);

}

else {

else

{

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

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

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

{

CIMProperty cp = cc->getProperty(i);

CIMName co;

Line 1897

Line 2181

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

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

//@HACK

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

//cout << "ci->getPropertyCount () = " << ci->getPropertyCount () << endl;

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

{

//cout << ci->getProperty (i).getName ().getString ()

// << " "

// << ci->getProperty (i).getQualifierCount ()

// << " "

// << ci->getProperty (i).findQualifier (CIMName ("key"))

// << endl;

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

{

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

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

Line 1956

Line 2250

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

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

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

{

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

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

Line 1985

Line 2280

CIMInstance *cf = 0;

CIMName clsn = ci->getClassName();

if (lo) {

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

{

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

cf->removeProperty (i);

}

return DEBUG_ConvertCToJava (CIMInstance*, jint, cf);

}

else if (jPl) {

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

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

{

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

if (pos!=PEG_NOT_FOUND) {

if (pos!= PEG_NOT_FOUND)

if (iq) {

{

if (iq)

{

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

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

if (!ic)

cp.setClassOrigin (CIMName ());

cf->addProperty(cp);

}

else {

else

{

CIMProperty cp=ci->getProperty(pos);

CIMName co;

if (ic) co=cp.getClassOrigin();

if (ic)

co = cp.getClassOrigin ();

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

cp.getReferenceClassName(),co,cp.getPropagated());

cf->addProperty(np);

Line 2016

Line 2322

}

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

}

else if (iq) {

else if (iq)

{

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

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

if (ic)

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

return DEBUG_ConvertCToJava (CIMInstance*, jint, cf);

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

{

CIMProperty cp=cf->getProperty(i);

cp.setClassOrigin(CIMName());

cf->removeProperty(i);

cf->addProperty(cp);

}

else {

else

{

cf=new CIMInstance(clsn);

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

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

{

CIMProperty cp=ci->getProperty(i);

CIMName co;

if (ic) co=cp.getClassOrigin();

if (ic)

co = cp.getClassOrigin ();

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

cp.getReferenceClassName(),co,cp.getPropagated());

cf->addProperty(np);

Line 2042

Line 2354

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

Line 2087

Line 2497

const char *str2 = NULL;

try {

if (jCn) str1=jEnv->GetStringUTFChars(jCn,NULL);

if (jCn)

if (jNs) str2=jEnv->GetStringUTFChars(jNs,NULL);

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

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

if (jNs)

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

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

if (str1)

cop->setClassName (str1);

if (str2)

cop->setNameSpace (str2);

}

Catch(jEnv);

if (str1) jEnv->ReleaseStringUTFChars(jCn,str1);

if (str1)

if (str2) jEnv->ReleaseStringUTFChars(jNs,str2);

jEnv->ReleaseStringUTFChars (jCn,str1);

if (str2)

jEnv->ReleaseStringUTFChars (jNs,str2);

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);

}

Line 2107

Line 2523

CIMObjectPath *cop = new CIMObjectPath(ci->getPath());

_nameSpace n;

if (cop->getNameSpace().isNull()) cop->setNameSpace(n.nameSpace());

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

if (cop->getHost()==NULL) cop->setHost(n.hostName());

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

if (cop->getHost () == NULL)

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

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);

}

Line 2211

Line 2629

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

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

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

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

{

const String &n=akb[i].getName().getString();

const String &v=akb[i].getValue();

CIMKeyBinding::Type t=akb[i].getType();

Line 2293

Line 2712

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

Array<CIMKeyBinding> akb;

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

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

Line 2408

Line 2828

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

jstring str = NULL;

if (dt->_type & 0x10) {

if (dt->_type & 0x10)

char tmp[32];

{

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

bool fSuccess = false;

strcat(tmp,"[]");

String tmp = _dataType::convertJavaTypeToChars (dt->_type-0x10, &fSuccess);

str=jEnv->NewStringUTF(tmp);

if (!fSuccess)

return str;

tmp = tmp + "[]";

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

}

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

else if (dt->_type == 0x20 + 1) // REFERENCE

{

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

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

}

else {

else

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

{

bool fSuccess = false;

char *tmp = _dataType::convertJavaTypeToChars (dt->_type, &fSuccess);

if (!fSuccess)

return str;

str = jEnv->NewStringUTF (tmp);

}

return str;

Line 2435

Line 2870

DEBUG_ConvertCleanup (jint, jDt);

}

CIMType toPtype (int jType)

{

if (jType > 13)

return (CIMType)14;

return

(CIMType)(jTypeToPType[jType]);

}

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

// ---

Line 2527

Line 2954

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

const CIMValue cv = cp->getValue();

String ref;

_dataType *type = new _dataType(pTypeToJType[cv.getType()],

bool fSuccess = false;

int iJType = 0;

_dataType *type = 0;

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

if (fSuccess)

{

type = new _dataType (iJType,

cv.getArraySize(),

false,

cv.isArray(),

ref,

true);

}

return DEBUG_ConvertCToJava (_dataType*, jint, type);

}

Line 2720

Line 3156

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

Line 2728

Line 3172

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

Line 2803

Line 3255

{

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

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

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

bool fSuccess = false;

int iJType = 0;

_dataType *type = 0;

iJType = _dataType::convertCTypeToJavaType (cp->getType (), &fSuccess);

if (fSuccess)

{

type = new _dataType (iJType,

cp->getArraySize(),

ref.size() ? true : false,

false,

cp->isArray(),

ref,

true);

}

return DEBUG_ConvertCToJava (_dataType*, jint, type);

}

Line 2818

Line 3279

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

{

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

_dataType *dt = (_dataType*)jDt;

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

CIMValue val;

bool fSuccess = false;

CIMType cType = CIMTYPE_BOOLEAN;

val.setNullValue(toPtype(dt->_type),dt->_array);

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)

Line 2850

Line 3324

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

Line 3035

Line 3555

{

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

return DEBUG_ConvertCToJava (CIMType, jint, new CIMType (cm->getType()));

return DEBUG_ConvertCToJava (CIMType *, jint, new CIMType (cm->getType ()));

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize

Line 3081

Line 3601

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue_makeInt

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1makeInt

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

{

CIMValue *cv = NULL;

Line 3134

Line 3654

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1ref

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1cop

(JNIEnv *jEnv, jobject jThs, jint jR)

{

CIMObjectPath *ref = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jR);

Line 3152

Line 3672

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)

{

Line 3176

Line 3714

jsize len = jEnv->GetArrayLength(jshortA);

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

if (notSigned) {

if (notSigned)

{

Array<Uint8> u8;

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

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

cv=new CIMValue(u8);

}

else {

else

{

Array<Sint8> s8;

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

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

cv=new CIMValue(s8);

}

jEnv->ReleaseShortArrayElements (jshortA, jsA, len);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

Line 3200

Line 3742

jsize len = jEnv->GetArrayLength(jintA);

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

if (notSigned) {

if (notSigned)

{

Array<Uint16> u16;

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

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

cv=new CIMValue(u16);

}

else {

else

{

Array<Sint16> s16;

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

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

cv=new CIMValue(s16);

}

jEnv->ReleaseIntArrayElements (jintA, jiA, len);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

Line 3224

Line 3770

jsize len = jEnv->GetArrayLength(jlongA);

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

if (notSigned) {

if (notSigned)

{

Array<Uint32> u32;

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

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

cv=new CIMValue(u32);

}

else {

else

{

Array<Sint32> s32;

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

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

cv=new CIMValue(s32);

}

jEnv->ReleaseLongArrayElements (jlongA, jlA, len);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

Line 3248

Line 3798

jsize len = jEnv->GetArrayLength(jlongA);

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

if (notSigned) {

if (notSigned)

{

Array<Uint64> u64;

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

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

cv=new CIMValue(u64);

}

else {

else

{

Array<Sint64> s64;

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

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

cv=new CIMValue(s64);

}

jEnv->ReleaseLongArrayElements (jlongA, jlA, len);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

Line 3268

Line 3822

(JNIEnv *jEnv, jobject jThs, jobjectArray jstringA)

{

CIMValue *cv = NULL;

jboolean b;

jsize len = jEnv->GetArrayLength(jstringA);

Array<String> strA;

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

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

{

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

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

Line 3299

Line 3853

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__1refArray

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1copArray

(JNIEnv *jEnv, jobject jThs, jintArray jintA)

{

CIMValue *cv = NULL;

Line 3315

Line 3907

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

}

Line 3322

Line 3970

(JNIEnv *jEnv, jobject jThs, jint jP)

{

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

bool fSuccess = false;

int iJType = 0;

return DEBUG_ConvertCToJava (int, jint, pTypeToJType[cv->getType()]);

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

return DEBUG_ConvertCToJava (int, jint, iJType);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString

Line 3346

Line 3998

CIMType type=cv->getType();

if (!cv->isArray()) {

if (!cv->isArray ())

switch (type) {

{

switch (type)

{

case CIMTYPE_BOOLEAN:

Boolean bo;

cv->get(bo);

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

return jEnv->NewObject (JMPIjvm::jv.BooleanClassRef,

break;

JMPIjvm::jv.BooleanNewZ,

bo);

case CIMTYPE_SINT8:

Sint8 s8;

cv->get(s8);

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

return jEnv->NewObject (JMPIjvm::jv.ByteClassRef,

break;

JMPIjvm::jv.ByteNewB,

s8);

case CIMTYPE_UINT8:

Uint8 u8;

cv->get(u8);

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

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef,

break;

JMPIjvm::jv.UnsignedInt8NewS,

u8);

case CIMTYPE_SINT16:

Sint16 s16;

cv->get(s16);

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

return jEnv->NewObject (JMPIjvm::jv.ShortClassRef,

break;

JMPIjvm::jv.ShortNewS,

s16);

case CIMTYPE_UINT16:

Uint16 u16;

cv->get(u16);

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

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef,

break;

JMPIjvm::jv.UnsignedInt16NewI,

u16);

case CIMTYPE_SINT32:

Sint32 s32;

cv->get(s32);

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

return jEnv->NewObject (JMPIjvm::jv.IntegerClassRef,

break;

JMPIjvm::jv.IntegerNewI,

s32);

case CIMTYPE_UINT32:

Uint32 u32;

cv->get(u32);

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

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef,

break;

JMPIjvm::jv.UnsignedInt32NewJ,

u32);

case CIMTYPE_SINT64:

Sint64 s64;

cv->get(s64);

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

return jEnv->NewObject (JMPIjvm::jv.LongClassRef,

break;

JMPIjvm::jv.LongNewJ,

case CIMTYPE_UINT64: {

s64);

case CIMTYPE_UINT64:

{

Uint64 u64;

cv->get(u64);

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

jobject jBIG = jEnv->CallStaticObjectMethod (JMPIjvm::jv.BigIntegerClassRef,

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

JMPIjvm::jv.BigIntegerValueOf,

u64);

return jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,

JMPIjvm::jv.UnsignedInt64NewBi,

jBIG);

}

break;

case CIMTYPE_REAL32:

float f;

cv->get(f);

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

return jEnv->NewObject (JMPIjvm::jv.FloatClassRef,

break;

JMPIjvm::jv.FloatNewF,

f);

case CIMTYPE_REAL64:

double d;

cv->get(d);

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

return jEnv->NewObject (JMPIjvm::jv.DoubleClassRef,

break;

JMPIjvm::jv.DoubleNewD,

case CIMTYPE_STRING: {

d);

case CIMTYPE_STRING:

{

String s;

jstring str;

cv->get(s);

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

return jEnv->NewStringUTF (s.getCString ());

return str;

}

break;

case CIMTYPE_REFERENCE:

case CIMTYPE_REFERENCE: {

{

CIMObjectPath ref;

cv->get(ref);

jint jOp = DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(ref));

return jEnv->NewObject(JMPIjvm::jv.CIMObjectPathClassRef,JMPIjvm::jv.CIMObjectPathNewI,jOp);

return jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef,

JMPIjvm::jv.CIMObjectPathNewI,

jOp);

}

break;

case CIMTYPE_CHAR16:

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

{

break;

Char16 c16;

case CIMTYPE_DATETIME: {

cv->get (c16);

return jEnv->NewObject (JMPIjvm::jv.CharacterClassRef,

JMPIjvm::jv.CharacterNewC,

(jchar)c16);

}

case CIMTYPE_DATETIME:

{

CIMDateTime dt;

cv->get(dt);

jint jDT = DEBUG_ConvertCToJava (CIMDateTime*, jint, new CIMDateTime(dt));

return jEnv->NewObject(JMPIjvm::jv.CIMDateTimeClassRef,JMPIjvm::jv.CIMDateTimeNewI,jDT);

return jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef,

JMPIjvm::jv.CIMDateTimeNewI,

jDT);

}

break;

case CIMTYPE_OBJECT:

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

{

break;

CIMObject co;

cv->get (co);

if (co.isClass ())

{

jint jCC = DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass (co));

return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,

JMPIjvm::jv.CIMObjectNewIZ,

jCC,

(jboolean)true);

}

else

{

jint jCI = DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance (co));

return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,

JMPIjvm::jv.CIMObjectNewIZ,

jCI,

(jboolean)false);

}

default:

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

}

else {

else

switch (type) {

{

case CIMTYPE_BOOLEAN: {

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

jobjectArray jbooleanA = (jobjectArray)jEnv->NewObjectArray (s,

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

JMPIjvm::jv.BooleanClassRef,

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

0);

for (int i = 0; i < s; i++)

jEnv->SetObjectArrayElement (jbooleanA,

jEnv->NewObject (JMPIjvm::jv.BooleanClassRef,

JMPIjvm::jv.BooleanNewZ,

bo[i]));

return jbooleanA;

}

break;

case CIMTYPE_SINT8:

case CIMTYPE_SINT8: {

{

Array<Sint8> s8;

cv->get(s8);

int s=s8.size();

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

jobjectArray jbyteA = (jobjectArray)jEnv->NewObjectArray (s,

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

JMPIjvm::jv.ByteClassRef,

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

0);

for (int i = 0; i < s; i++)

jEnv->SetObjectArrayElement (jbyteA,

jEnv->NewObject (JMPIjvm::jv.ByteClassRef,

JMPIjvm::jv.ByteNewB,

s8[i]));

return jbyteA;

}

break;

case CIMTYPE_UINT8:

case CIMTYPE_UINT8: {

{

Array<Uint8> u8;

cv->get(u8);

int s=u8.size();

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

jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray (s,

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

JMPIjvm::jv.UnsignedInt8ClassRef,

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

0);

for (int i = 0; i < s; i++)

jEnv->SetObjectArrayElement (jshortA,

jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef,

JMPIjvm::jv.UnsignedInt8NewS,

u8[i]));

return jshortA;

}

break;

case CIMTYPE_SINT16:

case CIMTYPE_SINT16: {

{

Array<Sint16> s16;

cv->get(s16);

int s=s16.size();

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

jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray (s,

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

JMPIjvm::jv.ShortClassRef,

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

0);

for (int i = 0; i < s; i++)

jEnv->SetObjectArrayElement (jshortA,

jEnv->NewObject (JMPIjvm::jv.ShortClassRef,

JMPIjvm::jv.ShortNewS,

s16[i]));

return jshortA;

}

break;

case CIMTYPE_UINT16:

case CIMTYPE_UINT16: {

{

Array<Uint16> u16;

cv->get(u16);

int s=u16.size();

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

jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray (s,

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

JMPIjvm::jv.UnsignedInt16ClassRef,

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

0);

for (int i = 0; i < s; i++)

jEnv->SetObjectArrayElement (jintA,

jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef,

JMPIjvm::jv.UnsignedInt16NewI,

u16[i]));

return jintA;

}

break;

case CIMTYPE_SINT32:

case CIMTYPE_SINT32: {

{

Array<Sint32> s32;

cv->get(s32);

int s=s32.size();

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

jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray (s,

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

JMPIjvm::jv.IntegerClassRef,

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

0);

for (int i = 0; i < s; i++)

jEnv->SetObjectArrayElement (jintA,

jEnv->NewObject (JMPIjvm::jv.IntegerClassRef,

JMPIjvm::jv.IntegerNewI,

s32[i]));

return jintA;

}

break;

case CIMTYPE_UINT32:

case CIMTYPE_UINT32: {

{

Array<Uint32> u32;

cv->get(u32);

int s=u32.size();

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

jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray (s,

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

JMPIjvm::jv.UnsignedInt32ClassRef,

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

0);

for (int i = 0; i < s; i++)

jEnv->SetObjectArrayElement (jlongA,

jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef,

JMPIjvm::jv.UnsignedInt32NewJ,

u32[i]));

return jlongA;

}

break;

case CIMTYPE_SINT64:

case CIMTYPE_SINT64: {

{

Array<Sint64> s64;

cv->get(s64);

int s=s64.size();

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

jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray (s,

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

JMPIjvm::jv.LongClassRef,

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

0);

for (int i = 0; i < s; i++)

jEnv->SetObjectArrayElement (jlongA,

jEnv->NewObject (JMPIjvm::jv.LongClassRef,

JMPIjvm::jv.LongNewJ,

s64[i]));

return jlongA;

}

break;

case CIMTYPE_UINT64:

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

{

break;

Array<Uint64> u64;

case CIMTYPE_REAL32: {

cv->get (u64);

int s = u64.size ();

jobjectArray ju64A = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.UnsignedInt64ClassRef,

0);

for (int i = 0; i < s; i++)

{

jobject jBIG = jEnv->CallStaticObjectMethod (JMPIjvm::jv.BigIntegerClassRef,

JMPIjvm::jv.BigIntegerValueOf,

u64[i]);

jEnv->SetObjectArrayElement (ju64A,

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

jobjectArray jfloatA = (jobjectArray)jEnv->NewObjectArray (s,

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

JMPIjvm::jv.FloatClassRef,

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

0);

for (int i = 0; i < s; i++)

jEnv->SetObjectArrayElement (jfloatA,

jEnv->NewObject (JMPIjvm::jv.FloatClassRef,

JMPIjvm::jv.FloatNewF,

r32[i]));

return jfloatA;

}

break;

case CIMTYPE_REAL64:

case CIMTYPE_REAL64: {

{

Array<Real64> r64;

cv->get(r64);

int s=r64.size();

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

jobjectArray jdoubleA = (jobjectArray)jEnv->NewObjectArray (s,

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

JMPIjvm::jv.DoubleClassRef,

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

0);

for (int i = 0; i < s; i++)

jEnv->SetObjectArrayElement (jdoubleA,

jEnv->NewObject (JMPIjvm::jv.DoubleClassRef,

JMPIjvm::jv.DoubleNewD,

r64[i]));

return jdoubleA;

}

break;

case CIMTYPE_STRING:

case CIMTYPE_STRING: {

{

Array<String> str;

cv->get(str);

int s=str.size();

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

jobjectArray jstringA = (jobjectArray)jEnv->NewObjectArray (s,

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

JMPIjvm::jv.StringClassRef,

0);

for (int i = 0; i < s; i++)

jEnv->SetObjectArrayElement (jstringA,

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

return jstringA;

}

break;

case CIMTYPE_REFERENCE:

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

{

break;

Array<CIMObjectPath> ref;

cv->get (ref);

int s = ref.size ();

jobjectArray jrefA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.CIMObjectPathClassRef,

0);

for (int i = 0; i < s; i++)

{

jint jOP = DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath (ref[i]));

jEnv->SetObjectArrayElement (jrefA,

jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef,

JMPIjvm::jv.CIMObjectPathNewI,

jOP));

}

return jrefA;

}

case CIMTYPE_CHAR16:

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

{

break;

Array<Char16> c16;

cv->get (c16);

int s = c16.size ();

jobjectArray jc16A = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.CharacterClassRef,

0);

for (int i = 0; i < s; i++)

jEnv->SetObjectArrayElement (jc16A,

jEnv->NewObject (JMPIjvm::jv.CharacterClassRef,

JMPIjvm::jv.CharacterNewC,

(jchar)c16[i]));

return jc16A;

}

case CIMTYPE_DATETIME:

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

{

break;

Array<CIMDateTime> dt;

cv->get (dt);

int s = dt.size ();

jobjectArray jdtA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.CIMDateTimeClassRef,

0);

for (int i = 0; i < s; i++)

{

jint jDT = DEBUG_ConvertCToJava (CIMDateTime*, jint, new CIMDateTime (dt[i]));

jEnv->SetObjectArrayElement (jdtA,

jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef,

JMPIjvm::jv.CIMDateTimeNewI,

jDT));

}

return jdtA;

}

case CIMTYPE_OBJECT:

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

{

break;

Array<CIMObject> co;

cv->get (co);

int s = co.size ();

jobjectArray jcoA = (jobjectArray)jEnv->NewObjectArray (s,

JMPIjvm::jv.CIMObjectClassRef,

0);

for (int i = 0; i < s; i++)

{

if (co[i].isClass ())

{

jint jCC = DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass (co[i]));

jEnv->SetObjectArrayElement (jcoA,

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

}

Line 3588

Line 4495

// ---

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

_nameSpace::_nameSpace() {

_nameSpace::_nameSpace ()

{

port_=0;

hostName_=System::getHostName();

nameSpace_="root/cimv2";

}

_nameSpace::_nameSpace(String hn) {

_nameSpace::_nameSpace (String hn)

{

port_=0;

hostName_=hn;

nameSpace_="root/cimv2";

}

_nameSpace::_nameSpace(String hn, String ns) {

_nameSpace::_nameSpace (String hn, String ns)

{

port_=0;

hostName_=hn;

nameSpace_=ns;

}

int _nameSpace::port() {

int _nameSpace::port ()

if (port_) return port_;

{

if (port_)

return port_;

port_=5988;

if (hostName_.subString(0,7)=="http://") {

if (hostName_.subString (0,7) == "http://")

{

protocol_="http://";

hostName_=hostName_.subString(7);

}

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

if (p>=0) {

if (p>= 0)

{

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

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

hostName_.remove(p);

Line 3622

Line 4536

return port_;

}

String _nameSpace::hostName() {

String _nameSpace::hostName ()

{

port();

return hostName_;

}

String _nameSpace::nameSpace() {

String _nameSpace::nameSpace ()

{

return nameSpace_;

}

Line 3792

Line 4708

// ---

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

void checkNs(CIMObjectPath *cop, jint jNs) {

void checkNs (CIMObjectPath *cop, jint jNs)

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

{

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

{

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

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

Line 3921

Line 4839

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

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

Line 4157

Line 5076

Array<CIMParamValue> in;

Array<CIMParamValue> out;

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

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

{

JMPIjvm::checkException(jEnv);

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

Line 4176

Line 5096

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

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

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

{

const CIMParamValue &parm = out[i];

const CIMValue v = parm.getValue();

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

Line 4209

Line 5130

Array<CIMParamValue> in;

Array<CIMParamValue> out;

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

if (jIn)

{

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

{

JMPIjvm::checkException(jEnv);

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

Line 4222

Line 5146

in.append(*p);

}

try {

checkNs(cop,jNs);

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

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

if (jOut)

{

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

Line 4234

Line 5162

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

}

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

}

Catch(jEnv);

Line 4287

Line 5216

checkNs(cop,jNs);

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

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

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

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

{

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

}

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

Line 4304

Line 5234

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

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

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

CIMName assocClass(str);

CIMName assocClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

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

jEnv->Throw ((jthrowable)ev);

return 0;

}

jEnv->ReleaseStringUTFChars(jAssocClass,str);

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

CIMName resultClass(str);

CIMName resultClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

resultClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

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

jEnv->Throw ((jthrowable)ev);

return 0;

}

jEnv->ReleaseStringUTFChars(jResultClass,str);

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

String role(str);

jEnv->ReleaseStringUTFChars(jRole,str);

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

String resultRole(str);

Line 4325

Line 5301

try {

checkNs(cop,jNs);

Array<CIMObjectPath> enm=cCc->associatorNames(

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

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

*cop,

assocClass,

resultClass,

role,

resultRole);

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

}

Catch(jEnv);

Line 4343

Line 5324

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

CIMName assocClass;

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

CIMName resultClass(str);

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

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

jEnv->ReleaseStringUTFChars(jResultClass,str);

jEnv->Throw ((jthrowable)ev);

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

String role(str);

return 0;

}

jEnv->ReleaseStringUTFChars(jRole,str);

jEnv->ReleaseStringUTFChars (jAssocClass, str);

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

String resultRole(str);

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

jEnv->ReleaseStringUTFChars(jResultRole,str);

CIMName resultClass;

try {

if ( str

checkNs(cop,jNs);

&& *str

Array<CIMObject> enm=cCc->associators(

)

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

{

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

if (CIMName::legal (str))

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

{

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

resultClass = str;

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

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

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

jEnv->Throw ((jthrowable)ev);

return 0;

}

jEnv->ReleaseStringUTFChars (jResultClass, str);

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

String role (str);

jEnv->ReleaseStringUTFChars (jRole, str);

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

String resultRole (str);

jEnv->ReleaseStringUTFChars (jResultRole, str);

try {

checkNs (cop, jNs);

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

*cop,

assocClass,

resultClass,

role,

resultRole,

(Boolean)includeQualifiers,

(Boolean)includeClassOrigin,

pl);

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

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

{

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

}

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

}

Catch(jEnv);

Line 4385

Line 5422

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

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

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

CIMName assocClass(str);

CIMName assocClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

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

jEnv->Throw ((jthrowable)ev);

return 0;

}

jEnv->ReleaseStringUTFChars(jAssocClass,str);

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

String role(str);

Line 4396

Line 5456

try {

checkNs(cop,jNs);

Array<CIMObjectPath> enm=cCc->referenceNames(

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

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

*cop,

assocClass,

role);

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

}

Catch(jEnv);

Line 4414

Line 5478

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

CIMPropertyList pl = getList(jEnv,jPl);

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

CIMName assocClass(str);

CIMName assocClass;

if ( str

&& *str

)

{

if (CIMName::legal (str))

{

assocClass = str;

}

else

{

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

JMPIjvm::jv.CIMExceptionNewISt,

(jint)4, // CIM_ERR_INVALID_PARAMETER

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

jEnv->Throw ((jthrowable)ev);

return 0;

}

jEnv->ReleaseStringUTFChars(jAssocClass,str);

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

Line 4425

Line 5511

try {

checkNs(cop,jNs);

Array<CIMObject> enm=cCc->references(

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

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

*cop,

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

assocClass,

role,

(Boolean)includeQualifiers,

(Boolean)includeClassOrigin,

pl);

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

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

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

{

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

}

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

}

Catch(jEnv);

Line 4439

Line 5532

return 0;

}

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

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

{

Uint32 n=ns.size();

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

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

{

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

}

Line 4449

Line 5544

nsBase="root";

n=ns.reverseFind('/');

if (n!=PEG_NOT_FOUND) {

if (n!= PEG_NOT_FOUND)

{

lastNsComp=ns.subString(n+1);

nsBase=ns.subString(0,n);

}

Line 4491

Line 5587

try {

Array<CIMObjectPath> enm=cCc->enumerateInstanceNames(

cop->getNameSpace(),CIMName("__Namespace"));

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

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

{

CIMObjectPath &cop=enm[i];

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

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

Line 4542

Line 5639

DEBUG_ConvertCleanup (jint, jCc);

}

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

// ---

// - CIMObject

// ---

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObject__1newClass

(JNIEnv *jEnv, jobject jThs, jint jCc)

{

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

try {

CIMObject *cCo = new CIMObject (*cCc);

return DEBUG_ConvertCToJava (CIMObject*, jint, cCo);

}

Catch (jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObject__1newInstance

(JNIEnv *jEnv, jobject jThs, jint jCi)

{

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

try {

CIMObject *cCo = new CIMObject (*cCi);

return DEBUG_ConvertCToJava (CIMObject*, jint, cCo);

}

Catch (jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObject__1finalize

(JNIEnv *jEnv, jobject jThs, jint jInst)

{

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

delete co;

DEBUG_ConvertCleanup (jint, jInst);

}

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

// ---

// - OperationContext

// ---

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

* Class: OperationContext

* Method: _get

* Signature: (ILjava/lang/String;Ljava/lang/String;)Ljava/lang/Object;

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_OperationContext__1get

(JNIEnv *jEnv, jobject jThs, jint jInst, jstring jContainer, jstring jKey)

{

OperationContext *poc = DEBUG_ConvertJavaToC (jint, OperationContext*, jInst);

jobject jRet = 0;

if (!poc)

{

return jRet;

}

const char *pszContainer = jEnv->GetStringUTFChars (jContainer, NULL);

const char *pszKey = jEnv->GetStringUTFChars (jKey, NULL);

String container (pszContainer);

String key (pszKey);

///printf ("container: %s\n", pszContainer);

///printf ("key: %s\n", pszKey);

try {

if (container == "IdentityContainer")

{

IdentityContainer ic = poc->get (IdentityContainer::NAME);

/////////printf ("ic\n");

if (key == "userName")

{

String userName = ic.getUserName ();

////////////printf ("userName: %s\n", (const char*)userName.getCString ());

jRet = jEnv->NewStringUTF ((const char*)userName.getCString ());

}

else if (container == "SubscriptionInstanceContainer")

{

SubscriptionInstanceContainer sic = poc->get (SubscriptionInstanceContainer::NAME);

if (key == "subscriptionInstance")

{

CIMInstance ci = sic.getInstance ();

jint jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance (ci));

jRet = jEnv->NewObject (JMPIjvm::jv.CIMInstanceClassRef,

JMPIjvm::jv.CIMInstanceNewI,

jciRef);

}

else if (container == "SubscriptionInstanceNamesContainer")

{

SubscriptionInstanceNamesContainer sinc = poc->get (SubscriptionInstanceNamesContainer::NAME);

if (key == "subscriptionInstanceNames")

{

Array<CIMObjectPath> copa = sinc.getInstanceNames ();

jobjectArray jcopa = 0;

int jcopaLength = copa.size ();

jcopa = jEnv->NewObjectArray (jcopaLength,

JMPIjvm::jv.CIMObjectPathClassRef,

0);

for (int i = 0; i < jcopaLength; i++)

{

jEnv->SetObjectArrayElement (jcopa,

jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef,

JMPIjvm::jv.CIMObjectPathNewI,

new CIMObjectPath (copa[i])));

}

jRet = (jobject)jcopa;

}

else if (container == "SubscriptionFilterConditionContainer")

{

SubscriptionFilterConditionContainer sfcc = poc->get (SubscriptionFilterConditionContainer::NAME);

/////////printf ("sfcc\n");

if (key == "filterCondition")

{

String filterCondition = sfcc.getFilterCondition ();

////////////printf ("filterCondition: %s\n", (const char*)filterCondition.getCString ());

jRet = jEnv->NewStringUTF ((const char*)filterCondition.getCString ());

}

else if (key == "queryLanguage")

{

String queryLanguage = sfcc.getQueryLanguage ();

jRet = jEnv->NewStringUTF ((const char*)queryLanguage.getCString ());

}

else if (container == "SubscriptionFilterQueryContainer")

{

SubscriptionFilterQueryContainer sfqc = poc->get (SubscriptionFilterQueryContainer::NAME);

if (key == "filterQuery")

{

String filterQuery = sfqc.getFilterQuery ();

jRet = jEnv->NewStringUTF ((const char*)filterQuery.getCString ());

}

else if (key == "queryLanguage")

{

String queryLanguage = sfqc.getQueryLanguage ();

jRet = jEnv->NewStringUTF ((const char*)queryLanguage.getCString ());

}

else if (key == "sourceNameSpace")

{

CIMNamespaceName cimNameSpaceName = sfqc.getSourceNameSpace ();

String nameSpaceName = cimNameSpaceName.getString ();

jRet = jEnv->NewStringUTF ((const char*)nameSpaceName.getCString ());

}

else if (container == "SnmpTrapOidContainer")

{

SnmpTrapOidContainer stoc = poc->get (SnmpTrapOidContainer::NAME);

if (key == "snmpTrapOid")

{

String snmpTrapOid = stoc.getSnmpTrapOid ();

jRet = jEnv->NewStringUTF ((const char*)snmpTrapOid.getCString ());

}

Catch (jEnv);

///printf ("jRet: %08X\n", (int)jRet);

jEnv->ReleaseStringUTFChars (jContainer, pszContainer);

jEnv->ReleaseStringUTFChars (jKey, pszKey);

return jRet;

}

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

// ---

// - SelectExp

// ---

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

* Class: org_pegasus_jmpi_SelectExp

* Method: _finalize

* Signature: (I)V

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_SelectExp__1finalize

(JNIEnv *jEnv, jobject jThs, jint jWQLStmt)

{

WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jint, WQLSelectStatement*, jWQLStmt);

delete wql_stmt;

DEBUG_ConvertCleanup (jint, jWQLStmt);

}

* Class: org_pegasus_jmpi_SelectExp

* Method: _newSelectExp

* Signature: (Ljava/lang/String;)I

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_SelectExp__1newSelectExp

(JNIEnv *jEnv, jobject jThs, jstring jQuery)

{

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

WQLSelectStatement *wql_stmt = NULL;

String queryLanguage (CALL_SIGN_WQL);

String query (pszQuery);

wql_stmt = new WQLSelectStatement (queryLanguage, query);

DDD (PEGASUS_STD (cout)<<"--- Java_org_pegasus_jmpi_SelectExp__1newSelectExp: wql_stmt = "<<PEGASUS_STD (hex)<< (int)wql_stmt<<PEGASUS_STD (dec)<<PEGASUS_STD (endl));

try

{

WQLParser::parse (query, *wql_stmt);

}

catch (const Exception &e)

{

cerr << "Java_org_pegasus_jmpi_SelectExp__1newSelectExp: Caught: " << e.getMessage () << endl;

}

jEnv->ReleaseStringUTFChars (jQuery, pszQuery);

return DEBUG_ConvertCToJava (WQLSelectStatement *, jint, wql_stmt);

}

* Class: org_pegasus_jmpi_SelectExp

* Method: _getSelectString

* Signature: (I)Ljava/lang/String;

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_SelectExp__1getSelectString

(JNIEnv *jEnv, jobject jThs, jint jWQLStmt)

{

WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jint, WQLSelectStatement*, jWQLStmt);

String cond;

if (wql_stmt)

{

try

{

cond = wql_stmt->getQuery ();

}

catch (const Exception &e)

{

cerr << "Java_org_pegasus_jmpi_SelectExp__1getSelectString: Caught: " << e.getMessage () << endl;

cond = "";

}

else

{

cond = "";

}

return (jstring)jEnv->NewStringUTF (cond.getCString ());

}

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

// ---

// - JMPISelectList

// ---

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

* Class: org_pegasus_jmpi_JMPISelectList

* Method: _applyInstance

* Signature: (II)I

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyInstance

(JNIEnv *jEnv, jobject jThs, jint jWQLStmt, jint jciInstance)

{

WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jint, WQLSelectStatement*, jWQLStmt);

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

CIMInstance *ciRet = 0;

if ( !wql_stmt

|| !ci

)

{

return 0;

}

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

if (ciRet)

{

try

{

wql_stmt->applyProjection (*ciRet, false);

}

catch (const Exception &e)

{

cerr << "Java_org_pegasus_jmpi_JMPISelectList__1applyInstance: Caught: " << e.getMessage () << endl;

return 0;

}

return DEBUG_ConvertCToJava (CIMInstance *, jint, ciRet);

}

* Class: org_pegasus_jmpi_JMPISelectList

* Method: _applyClass

* Signature: (II)I

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyClass

(JNIEnv *jEnv, jobject jThs, jint jWQLStmt, jint jciClass)

{

WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jint, WQLSelectStatement*, jWQLStmt);

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

CIMClass *ccRet = NULL;

if (!wql_stmt)

{

return 0;

}

if (cc)

{

CIMObject co (cc->clone ());

try

{

wql_stmt->applyProjection (co, false);

}

catch (const Exception &e)

{

cerr << "Java_org_pegasus_jmpi_JMPISelectList__1applyClass: Caught: " << e.getMessage () << endl;

return 0;

}

ccRet = new CIMClass (co);

return DEBUG_ConvertCToJava (CIMClass *, jint, ccRet);

}

return 0;

}

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

// ---

// - JMPIQueryExp

// ---

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

* Class: org_pegasus_jmpi_JMPIQueryExp

* Method: _applyInstance

* Signature: (II)Z

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_JMPIQueryExp__1applyInstance

(JNIEnv *jEnv, jobject jThs, jint jWQLStmt, jint jciInstance)

{

WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jint, WQLSelectStatement*, jWQLStmt);

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

if ( !wql_stmt

|| !ci

)

{

return 0;

}

try

{

return wql_stmt->evaluate (*ci);

}

catch (const Exception &e)

{

cerr << "Java_org_pegasus_jmpi_JMPIQueryExp__1applyInstance: Caught: " << e.getMessage () << endl;

return false;

}

} // extern "C"

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.32
changed lines
	Added in v.1.44

No CVS admin address has been configured