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.19 and 1.25

version 1.19, 2005/04/07 19:59:30

version 1.25, 2005/06/01 01:51:54

Line 34

// Magda Vacarelu

// David Dillard, VERITAS Software Corp.

// (david.dillard@veritas.com)

// Mark Hamzy

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

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

Line 70

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

#include "Convert.h"

JMPIjvm::ClassTable JMPIjvm::_classTable;

JMPIjvm::ObjectTable JMPIjvm::_objectTable;

Line 164

Line 166

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

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

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

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

};

const METHOD_STRUCT staticMethodNames[]={

Line 177

Line 180

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

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

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

static jclass providerClassRef;

//static jclass providerClassRef;

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

jclass localRefCls=env->FindClass(name);

Line 307

Line 311

return -1;

}

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

///maxoption++;

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

{

const char *name = aENVoptions[i][0];

Line 683

Line 690

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

jboolean iq, jboolean ic, jobjectArray jPl)

CIMOMHandle *ch=(CIMOMHandle*)jCh;

{

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

if (jPl)

pl=getList(jEnv,jPl);

else

pl=CIMPropertyList();

try {

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

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

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

cop->getClassName(),

return (jint) new CIMClass(cls);

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

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

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

CIMClass *cl=(CIMClass*)jCl;

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

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

OperationContext ctx;

try {

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

}

Catch(jEnv);

return;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setClass

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

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

CIMClass *cl=(CIMClass*)jCl;

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

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

OperationContext ctx;

try {

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

}

Catch(jEnv);

return ;

}

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 {

Line 739

Line 759

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClassNames

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

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

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

CIMNamespaceName ns=cop->getNameSpace();

OperationContext ctx;

try {

Array<CIMName> enm=ch->enumerateClassNames(ctx,cop->getNameSpace(),cop->getClassName(),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 (jint)enmop;

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

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClasses

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

jboolean lo, jboolean iq, jboolean ic) {

jboolean lo, jboolean iq, jboolean ic)

CIMOMHandle *ch=(CIMOMHandle*)jCh;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

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

OperationContext ctx;

try {

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

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

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

cop->getNameSpace(),

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

cop->getClassName(),

deep,

(Boolean)lo,

iq,

ic);

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

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getInstance

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

jobjectArray jPl) {

jobjectArray jPl)

{

CIMOMHandle *ch=(CIMOMHandle*)jCh;

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

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

OperationContext ctx;

CIMPropertyList pl;

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

else pl=CIMPropertyList();

if (jPl)

pl=getList(jEnv,jPl);

else

pl=CIMPropertyList();

try {

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

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

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

cop->getNameSpace(),

return (jint)(void*)inst;

*cop,

(Boolean)lo,

(Boolean)iq,

(Boolean)ic,

pl));

return DEBUG_ConvertCToJava (CIMInstance*, jint, inst);

}

Catch(jEnv);

return -1;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance

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

Line 804

Line 848

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createInstance

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

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

CIMInstance *ci=(CIMInstance*)jCi;

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

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

OperationContext ctx;

try {

ci->setPath(*cop);

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

return (jint) new CIMObjectPath(obj);

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

}

Catch(jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1modifyInstance

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

jboolean iq, jobjectArray jPl) {

jboolean iq, jobjectArray jPl)

CIMOMHandle *ch=(CIMOMHandle*)jCh;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

CIMInstance *ci=(CIMInstance*)jCi;

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

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

CIMPropertyList pl=getList(jEnv,jPl);

OperationContext ctx;

try {

ci->setPath(*cop);

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

}

Catch(jEnv);

return ;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstanceNames

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

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

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

OperationContext ctx;

try {

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

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

cop->getNameSpace(),

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

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_CIMOMHandle__1enumerateInstances

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

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

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

{

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

if (jPl)

pl=getList(jEnv,jPl);

else

pl=CIMPropertyList();

try {

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

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

deep,lo,iq,ic,pl);

cop->getNameSpace(),

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

cop->getClassName(),

deep,

lo,

iq,

ic,

pl);

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

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1execQuery

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

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

jEnv->ReleaseStringUTFChars(jQl,str);

try {

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

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

}

return (jint)enmInst;

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

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getProperty

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

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

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

OperationContext ctx;

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

Line 903

Line 976

CIMName prop(str);

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

jEnv->ReleaseStringUTFChars(jN,str);

return (jint)(void*)cv;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

Catch(jEnv);

return -1;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setProperty

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

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

jEnv->ReleaseStringUTFChars(jPn,str);

try {

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

}

Catch(jEnv);

return;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod

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

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

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

OperationContext ctx;

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

CIMName method(str);

jEnv->ReleaseStringUTFChars(jMn,str);

Array<CIMParamValue> in;

Line 942

Line 1017

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

JMPIjvm::checkException(jEnv);

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

JMPIjvm::checkException(jEnv);

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

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

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

JMPIjvm::checkException(jEnv);

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

}

try {

Line 955

Line 1036

const CIMParamValue & parm=out[i];

const CIMValue v=parm.getValue();

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

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

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

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

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

}

return (jint)val;

return DEBUG_ConvertCToJava (CIMValue*, jint, val);

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod24

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

jobjectArray jIn, jobjectArray jOut) {

jobjectArray jIn, jobjectArray jOut)

CIMOMHandle *ch=(CIMOMHandle*)jCh;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

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

OperationContext ctx;

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

CIMName method(str);

jEnv->ReleaseStringUTFChars(jMn,str);

Array<CIMParamValue> in;

Line 979

Line 1065

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

JMPIjvm::checkException(jEnv);

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

JMPIjvm::checkException(jEnv);

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

jint jp = jEnv->CallIntMethod(jArg,instanceMethodIDs[39]);

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

JMPIjvm::checkException(jEnv);

in.append(*p);

}

try {

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

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

const CIMParamValue & parm=out[i];

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

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

jEnv->SetObjectArrayElement(jOut,i,

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

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

}

return (jint)val;

return DEBUG_ConvertCToJava (CIMValue*, jint, val);

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associatorNames

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

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

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

CIMOMHandle *ch=(CIMOMHandle*)jCh;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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(jResultClass,NULL);

CIMName resultClass(str);

jEnv->ReleaseStringUTFChars(jResultClass,str);

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

String role(str);

jEnv->ReleaseStringUTFChars(jRole,str);

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

String resultRole(str);

jEnv->ReleaseStringUTFChars(jResultRole,str);

try {

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

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

cop->getNameSpace(),

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

*cop,

assocClass,

resultClass,

role,

resultRole);

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

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIM__1associators

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

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

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl) {

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)

CIMOMHandle *ch=(CIMOMHandle*)jCh;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

CIMPropertyList pl=getList(jEnv,jPl);

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

OperationContext ctx;

CIMPropertyList pl = getList(jEnv,jPl);

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

CIMName assocClass(str);

jEnv->ReleaseStringUTFChars(jAssocClass,str);

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

CIMName resultClass(str);

jEnv->ReleaseStringUTFChars(jResultClass,str);

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

String role(str);

jEnv->ReleaseStringUTFChars(jRole,str);

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

String resultRole(str);

jEnv->ReleaseStringUTFChars(jResultRole,str);

try {

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

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

cop->getNameSpace(),

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

*cop,

assocClass,

resultClass,

role,

resultRole,

(Boolean)includeQualifiers,

(Boolean)includeClassOrigin,

pl);

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

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

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

}

return (jint)enmInst;

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

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1referenceNames

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

jstring jAssocClass, jstring jRole) {

jstring jAssocClass, jstring jRole)

CIMOMHandle *ch=(CIMOMHandle*)jCh;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

cop->getNameSpace(),

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

*cop,

assocClass,

role);

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

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1references

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

jstring jAssocClass, jstring jRole,

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl) {

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)

CIMOMHandle *ch=(CIMOMHandle*)jCh;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

CIMPropertyList pl=getList(jEnv,jPl);

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

OperationContext ctx;

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 {

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

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

cop->getNameSpace(),

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

*cop,

assocClass,

role,

(Boolean)includeQualifiers,

(Boolean)includeClassOrigin,

pl);

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

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

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

}

return (jint)enmInst;

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

}

Catch(jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent

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

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

{

CIMOMHandle *ch=(CIMOMHandle*)jCh;

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

CIMInstance *ind=(CIMInstance*)jInd;

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

String ns(str);

jEnv->ReleaseStringUTFChars(jNs,str);

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

ref.setNameSpace(ns);

ind->setPath(ref);

Line 1155

Line 1309

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1finalize

(JNIEnv *jEnv, jobject jThs, jint jCh)

{

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

delete ch;

DEBUG_ConvertCleanup (jint, jCh);

}

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

// ---

// - CIMClass

Line 1162

Line 1326

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1newInstance

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

(JNIEnv *jEnv, jobject jThs, jint jCls)

CIMClass *cls=(CIMClass*)jCls;

{

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

try {

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

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

try {

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

Line 1174

Line 1341

}

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

CIMProperty cp= cls->getProperty(i);

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

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

try {

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

Line 1182

Line 1351

catch (Exception e) {}

}

return (jint)ci;

return DEBUG_ConvertCToJava (CIMInstance*, jint, ci);

}

Catch(jEnv);

return 0;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getName

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

(JNIEnv *jEnv, jobject jThs, jint jCls)

CIMClass *cls=(CIMClass*)jCls;

{

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

try {

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

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

return str;

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifier

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

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

CIMClass *cls=(CIMClass*)jCls;

{

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

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

jint rv=-1;

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

if (pos!=PEG_NOT_FOUND)

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

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

jEnv->ReleaseStringUTFChars(jN,str);

return rv;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperty

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

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

CIMClass *cls=(CIMClass*)jCls;

{

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=(jint)new CIMProperty(cls->getProperty(pos));

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

jEnv->ReleaseStringUTFChars(jN,str);

return rv;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1hasQualifier

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

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

CIMClass *cls=(CIMClass*)jCls;

{

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 jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties

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

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

CIMClass *cls=(CIMClass*)jCls;

{

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

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

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

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

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

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

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

}

return jVec;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1addProperty

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

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

CIMClass *cls=(CIMClass*)jCls;

{

CIMProperty *p=(CIMProperty*)jP;

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

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

cls->addProperty(*p);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1setProperties

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

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

CIMClass *cls=(CIMClass*)jCls;

{

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

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

cls->removeProperty(i);

}

for (Uint32 i=0,s=jEnv->CallIntMethod(jVec,instanceMethodIDs[28]); i<s; i++) {

JMPIjvm::checkException(jEnv);

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

CIMProperty *cp=(CIMProperty*)jEnv->CallIntMethod(o,instanceMethodIDs[29]);

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

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

JMPIjvm::checkException(jEnv);

cls->addProperty(*cp);

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifiers

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

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

CIMClass *cls=(CIMClass*)jCls;

{

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

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

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

jobject qual=jEnv->NewObject(classRefs[26],instanceMethodIDs[37],(jint)cq);

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

jobject qual = jEnv->NewObject(classRefs[26],instanceMethodIDs[37],jCq);

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

}

return jVec;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1new

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

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

return DEBUG_ConvertCToJava (CIMClass*, jint, cls);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getSuperClass

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

(JNIEnv *jEnv, jobject jThs, jint jCls)

CIMClass *cls =(CIMClass *)jCls;

{

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

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

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

return str;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getKeys

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

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

CIMClass *cls=(CIMClass*)jCls;

{

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

if (cls->hasKeys()) {

Array<CIMName> keyNames;

cls->getKeyNames(keyNames);

Line 1307

Line 1518

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

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

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

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

}

return jVec;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethod

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

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

CIMClass *cls=(CIMClass*)jCls;

{

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=(jint)new CIMMethod(cls->getMethod(pos));

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

}

jEnv->ReleaseStringUTFChars(jN,str);

return rv;

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1equals

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

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

CIMClass *cls = (CIMClass*)jCls;

{

CIMClass *clsToBeCompared = (CIMClass*)jClsToBeCompared;

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

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

return cls->identical(*clsToBeCompared);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1finalize

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

(JNIEnv *jEnv, jobject jThs, jint jCls)

CIMClass *cls=(CIMClass*)jCls;

{

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

delete cls;

DEBUG_ConvertCleanup (jint, jCls);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1filterProperties

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

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

CIMClass *cc=(CIMClass *)jInst;

{

CIMClass* cf;

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

CIMClass *cf = 0;

CIMName clsn=cc->getClassName();

if (lo) {

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

CIMName clsn=cc->getClassName();

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

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

return (jint)cf;

}

return DEBUG_ConvertCToJava (CIMClass*, jint, cf);

}

else if (jPl) {

CIMPropertyList pl=getList(jEnv,jPl);

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

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

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

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

if (pos!=PEG_NOT_FOUND) {

if (iq) {

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

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

if (!ic)

cp.setClassOrigin(CIMName());

cf->addProperty(cp);

}

else {

CIMProperty cp=cc->getProperty(pos);

CIMName co;

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

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

if (ic)

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

co = cp.getClassOrigin();

CIMProperty np(cp.getName(),

cp.getValue(),

cp.getArraySize(),

cp.getReferenceClassName(),

co,

cp.getPropagated());

cf->addProperty(np);

}

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

if (iq)

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

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

}

else if (iq) {

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

if (ic) return (jint)cf;

if (ic)

return DEBUG_ConvertCToJava (CIMClass*, jint, cf);

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

CIMProperty cp=cf->getProperty(i);

cp.setClassOrigin(CIMName());

cf->removeProperty(i);

cf->addProperty(cp);

}

else {

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

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

CIMProperty cp=cc->getProperty(i);

CIMName co;

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

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

if (ic)

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

co = cp.getClassOrigin();

CIMProperty np(cp.getName(),

cp.getValue(),

cp.getArraySize(),

cp.getReferenceClassName(),

co,

cp.getPropagated());

cf->addProperty(np);

}

return (jint)cf;

return DEBUG_ConvertCToJava (CIMClass*, jint, cf);

}

Line 1416

Line 1670

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1new

(JNIEnv *jEnv, jobject jThs) {

(JNIEnv *jEnv, jobject jThs)

return (jint)new CIMInstance();

{

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

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1newCn

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

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

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

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

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

}

//Added by Andy Viciu

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setName

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

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

CIMInstance *ci=(CIMInstance*)jInst;

{

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

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

CIMInstance *ci=(CIMInstance*)jInst;

{

CIMValue *cv=(CIMValue*)jV;

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

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

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

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

try {

if (pos!=PEG_NOT_FOUND) {

CIMProperty cp=ci->getProperty(pos);

Line 1465

Line 1726

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperties

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

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

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

CIMInstance *ci=(CIMInstance*)jInst;

{

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=(jint)cp;

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

}

Catch(jEnv);

jEnv->ReleaseStringUTFChars(jN,str);

return rv;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getKeyValuePairs

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

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

CIMInstance *ci=(CIMInstance*)jInst;

{

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

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

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

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

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

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

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

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

}

Line 1502

Line 1774

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMInstance__1getClassName

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

(JNIEnv *jEnv, jobject jThs, jint jInst)

CIMInstance *ci=(CIMInstance*)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) {

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

CIMInstance *ci=(CIMInstance*)jInst;

{

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=(jint)new CIMQualifier(ci->getQualifier(pos));

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

(JNIEnv *jEnv, jobject jThs, jint jInst)

CIMInstance *ci=(CIMInstance *)jInst;

{

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

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

return (jint)(void*)cl;

return DEBUG_ConvertCToJava (CIMInstance*, jint, cl);

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperties

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

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

CIMInstance *ci=(CIMInstance*)jInst;

{

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

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

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

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

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

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

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

}

Line 1545

Line 1828

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1finalize

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

(JNIEnv *jEnv, jobject jThs, jint jInst)

CIMInstance *ci=(CIMInstance*)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) {

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

CIMInstance *ci=(CIMInstance *)jInst;

{

CIMInstance* cf;

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

CIMInstance *cf = 0;

CIMName clsn=ci->getClassName();

if (lo) {

Line 1561

Line 1849

CIMName clsn=ci->getClassName();

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

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

return (jint)cf;

return DEBUG_ConvertCToJava (CIMInstance*, jint, cf);

}

else if (jPl) {

CIMPropertyList pl=getList(jEnv,jPl);

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

Line 1588

Line 1875

}

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

}

else if (iq) {

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

if (ic) return (jint)cf;

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

Line 1599

Line 1885

cf->addProperty(cp);

}

else {

cf=new CIMInstance(clsn);

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

Line 1613

Line 1898

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

}

return (jint)cf;

return DEBUG_ConvertCToJava (CIMInstance*, jint, cf);

}

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

Line 1622

Line 1907

// ---

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

CIMObjectPath* construct() {

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

(JNIEnv *jEnv, jobject jThs)

return (jint)construct();

{

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, construct());

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCn

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

(JNIEnv *jEnv, jobject jThs, jstring jCn)

{

CIMObjectPath *cop=construct();

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

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

if (str)

cop->setClassName(str);

jEnv->ReleaseStringUTFChars(jCn,str);

return (jint)(void*)cop;

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCnNs

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

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

{

CIMObjectPath *cop=construct();

const char *str1=NULL;

const char *str2=NULL;

Line 1660

Line 1954

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

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

return (jint)(void*)cop;

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1_newCi

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

(JNIEnv *jEnv, jobject jThs, jint jInst)

CIMInstance *ci = (CIMInstance *)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 (jint)(void*)cop;

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1finalize

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

(JNIEnv *jEnv, jobject jThs, jint jCop)

CIMObjectPath *cop=(CIMObjectPath*)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 jOp) {

(JNIEnv *jEnv, jobject jThs, jint jCop)

CIMObjectPath *cop=(CIMObjectPath*)jOp;

{

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 jOp, jstring jName) {

(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jName)

CIMObjectPath *cop=(CIMObjectPath*)jOp;

{

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

(JNIEnv *jEnv, jobject jThs, jint jCop)

CIMObjectPath *cop=(CIMObjectPath*)jOp;

{

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 jOp, jstring jName) {

(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jName)

CIMObjectPath *cop=(CIMObjectPath*)jOp;

{

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

(JNIEnv *jEnv, jobject jThs, jint jCop)

CIMObjectPath *cop=(CIMObjectPath*)jOp;

{

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 jOp, jstring jName) {

(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jName)

CIMObjectPath *cop=(CIMObjectPath*)jOp;

{

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 jOp, jstring jId, jint jVal) {

(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jId, jint jVal)

CIMObjectPath *cop=(CIMObjectPath*)jOp;

{

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

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

CIMValue *cv=(CIMValue*)jVal;

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

return;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeys

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

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

CIMObjectPath *cop=(CIMObjectPath*)jOp;

{

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;

CIMValue *cv = 0;

switch (t) {

case CIMKeyBinding::NUMERIC:

cv=new CIMValue((Sint32)atol(v.getCString()));

Line 1766

Line 2085

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

}

CIMProperty *cp;

CIMProperty *cp = 0;

if(t!=CIMKeyBinding::REFERENCE)

cp=new CIMProperty(n,*cv);

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

else

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

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

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

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

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

}

return jVec;

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeyValue

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

(JNIEnv *jEnv, jobject jThs, jint jCop, jstring jStr)

CIMObjectPath *cop=(CIMObjectPath*)jOp;

{

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

Line 1790

Line 2115

break;

}

jEnv->ReleaseStringUTFChars(jStr,strKeyName);

return retStr;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1set

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

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

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setKeys

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

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

CIMObjectPath *cop=(CIMObjectPath*)jOp;

{

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

Array<CIMKeyBinding> akb;

for (Uint32 i=0,s=jEnv->CallIntMethod(jVec,instanceMethodIDs[28]); i<s; i++) {

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

CIMProperty *cp=(CIMProperty*)jEnv->CallIntMethod(o,instanceMethodIDs[29]);

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

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

(JNIEnv *jEnv, jobject jThs, jint jCop)

CIMObjectPath *cop=(CIMObjectPath*)jOp;

{

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

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

return (jint)(void*)copl;

return DEBUG_ConvertCToJava (CIMObjectPath*, jint, copl);

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1toString

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

(JNIEnv *jEnv, jobject jThs, jint jCop)

CIMObjectPath *cop=(CIMObjectPath*)jOp;

{

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

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

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

return str;

}

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

// ---

// - CIMDataType

Line 1838

Line 2177

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1new

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

(JNIEnv *jEnv, jobject jThs, jint type)

return (jint)(void*) new _dataType(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) {

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

return (jint)(void*) new _dataType(type,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) {

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

{

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

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

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

(JNIEnv *jEnv, jobject jThs, jint jDt)

_dataType *dt=(_dataType*)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) {

(JNIEnv *jEnv, jobject jThs, jint jDt)

_dataType *dt=(_dataType*)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) {

(JNIEnv *jEnv, jobject jThs, jint jDt)

_dataType *dt=(_dataType*)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) {

(JNIEnv *jEnv, jobject jThs, jint jDt)

_dataType *dt=(_dataType*)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) {

(JNIEnv *jEnv, jobject jThs, jint jDt)

_dataType *dt=(_dataType*)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) {

(JNIEnv *jEnv, jobject jThs, jint jDt)

_dataType *dt=(_dataType*)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) {

(JNIEnv *jEnv, jobject jThs, jint jDt)

_dataType *dt=(_dataType*)jDt;

{

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

jstring str=NULL;

if (dt->_type & 0x10) {

char tmp[32];

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

Line 1909

Line 2267

else {

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

}

return str;

}

CIMType toPtype(int jType) {

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDataType__1finalize

if (jType>13) return (CIMType)14;

(JNIEnv *jEnv, jobject jThs, jint jDt)

return (CIMType)(jTypeToPType[jType]);

{

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

delete dt;

DEBUG_ConvertCleanup (jint, jDt);

}

CIMType toPtype (int jType)

{

if (jType > 13)

return (CIMType)14;

return

(CIMType)(jTypeToPType[jType]);

}

Line 1925

Line 2297

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1getValue

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

(JNIEnv *jEnv, jobject jThs, jint jP)

CIMParamValue *cp=(CIMParamValue*)jP;

{

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

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

return (jint)cv;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1new

(JNIEnv *jEnv, jobject jThs) {

(JNIEnv *jEnv, jobject jThs)

{

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

return (jint)p;

return DEBUG_ConvertCToJava (CIMParamValue*, jint, p);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1newS

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

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

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

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

jEnv->ReleaseStringUTFChars(jN,str);

return (jint)p;

return DEBUG_ConvertCToJava (CIMParamValue*, jint, p);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1newSV

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

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

{

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

CIMValue *cv=(CIMValue*)jV;

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

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

jEnv->ReleaseStringUTFChars(jN,str);

return (jint)p;

return DEBUG_ConvertCToJava (CIMParamValue*, jint, p);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setValue

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

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

CIMParamValue *cp=(CIMParamValue*)jP;

{

CIMValue *cv=(CIMValue*)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) {

(JNIEnv *jEnv, jobject jThs, jint jP)

CIMParamValue *cp=(CIMParamValue*)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) {

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

CIMParamValue *cp=(CIMParamValue*)jP;

{

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

(JNIEnv *jEnv, jobject jThs, jint jP)

CIMParamValue *cp=(CIMParamValue*)jP;

{

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

const CIMValue cv=cp->getValue();

String ref;

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

Line 1990

Line 2379

cv.isArray(),

ref,

true);

return (jint)type;

}

return DEBUG_ConvertCToJava (_dataType*, jint, type);

}

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

// ---

Line 2003

Line 2390

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getValue

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

(JNIEnv *jEnv, jobject jThs, jint jP)

CIMProperty *cp=(CIMProperty*)jP;

{

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

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

return (jint)cv;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1new

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

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

{

CIMProperty *p=new CIMProperty(CIMName(),CIMValue());

return (jint)p;

return DEBUG_ConvertCToJava (CIMProperty*, jint, p);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1property

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

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

{

try {

CIMValue *cv=(CIMValue*)jV;

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

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

CIMProperty *cp;

CIMProperty *cp = 0;

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

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

Line 2036

Line 2428

}

jEnv->ReleaseStringUTFChars(jN,str);

return (jint)cp;

return DEBUG_ConvertCToJava (CIMProperty*, jint, cp);

}

Catch(jEnv);

return -1;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setValue

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

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

CIMProperty *cp=(CIMProperty*)jP;

{

CIMValue *cv=(CIMValue*)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) {

(JNIEnv *jEnv, jobject jThs, jint jP)

CIMProperty *cp=(CIMProperty*)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) {

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

CIMProperty *cp=(CIMProperty*)jP;

{

CIMValue *cvin=(CIMValue*)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;

Line 2186

Line 2588

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addQualifier

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

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

CIMProperty *cp=(CIMProperty*)jP;

{

CIMQualifier *cq=(CIMQualifier*)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) {

(JNIEnv *jEnv, jobject jThs, jint jP)

CIMProperty *cp=(CIMProperty*)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) {

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

CIMProperty *cp=(CIMProperty*)jP;

{

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

(JNIEnv *jEnv, jobject jThs, jint jP)

CIMProperty *cp=(CIMProperty*)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) {

(JNIEnv *jEnv, jobject jThs, jint jP)

CIMProperty *cp=(CIMProperty*)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) {

(JNIEnv *jEnv, jobject jThs, jint jP)

CIMProperty *cp=(CIMProperty*)jP;

{

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

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

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

cp->getArraySize(),

Line 2233

Line 2647

cp->isArray(),

ref,

true);

return (jint)type;

return DEBUG_ConvertCToJava (_dataType*, jint, type);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1setType

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

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

CIMProperty *cp=(CIMProperty*)jP;

{

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

_dataType *dt=(_dataType*)jDt;

CIMValue val;

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

CIMProperty *np=new CIMProperty(cp->getName(),val);

delete cp;

return (jint)np;

return DEBUG_ConvertCToJava (CIMProperty*, jint, np);

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMProperty__1getIdentifier

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

(JNIEnv *jEnv, jobject jThs, jint jP)

CIMProperty *cp=(CIMProperty*)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) {

(JNIEnv *jEnv, jobject jThs, jint jP)

CIMProperty *cp=(CIMProperty*)jP;

{

delete cp;

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

}

delete cp;

DEBUG_ConvertCleanup (jint, jP);

}

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

// ---

Line 2270

Line 2694

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1new

(JNIEnv *jEnv, jobject jThs) {

(JNIEnv *jEnv, jobject jThs)

{

CIMQualifierDecl *qual = new CIMQualifierDecl();

return (jint)(void*)qual;

return DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, qual);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1finalize

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

(JNIEnv *jEnv, jobject jThs, jint jQ)

CIMQualifierDecl *qt=(CIMQualifierDecl*)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) {

(JNIEnv *jEnv, jobject jThs, jint jQ)

CIMQualifierDecl *qt=(CIMQualifierDecl*)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) {

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

CIMQualifierDecl *nqt,*qt=(CIMQualifierDecl*)jQ;

{

nqt=qt;

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

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

jint jret = 0;

if (qt->isUninitialized())

nqt=new CIMQualifierDecl(CIMName(str),CIMValue(),CIMScope());

{

else qt->setName(CIMName(str));

CIMQualifierDecl *nqt = new CIMQualifierDecl(CIMName(str),CIMValue(),CIMScope());

jEnv->ReleaseStringUTFChars(jN,str);

return (jint)nqt;

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

}

else

{

qt->setName(CIMName(str));

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setValue

CIMQualifierDecl *nqt = new CIMQualifierDecl(*qt);

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

CIMQualifierDecl *qt=(CIMQualifierDecl*)jQ;

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

CIMValue *cv=(CIMValue*)jV;

qt->setValue(*cv);

}

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

}

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

// ---

Line 2319

Line 2764

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifier__1new

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

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

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

CIMQualifier *qual = new CIMQualifier(CIMName(str),CIMValue());

jEnv->ReleaseStringUTFChars(jN,str);

return (jint)(void*)qual;

return DEBUG_ConvertCToJava (CIMQualifier*, jint, qual);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1finalize

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

(JNIEnv *jEnv, jobject jThs, jint jQ)

CIMQualifier *cq=(CIMQualifier*)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) {

(JNIEnv *jEnv, jobject jThs, jint jQ)

CIMQualifier *cq=(CIMQualifier*)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) {

(JNIEnv *jEnv, jobject jThs, jint jQ)

CIMQualifier *cq=(CIMQualifier*)jQ;

{

CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);

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

return (jint)cv;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1setValue

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

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

CIMQualifier *cq=(CIMQualifier*)jQ;

{

CIMValue *cv=(CIMValue*)jV;

CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);

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

cq->setValue(*cv);

}

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

// ---

// - CIMDateTime

Line 2362

Line 2819

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetime

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

(JNIEnv *jEnv, jobject jThs, jstring jN)

{

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

CIMDateTime *dt;

CIMDateTime *dt = 0;

if (strlen(str)==0)

dt=new CIMDateTime();

else

dt=new CIMDateTime(String(str));

jEnv->ReleaseStringUTFChars(jN,str);

return (jint)dt;

return DEBUG_ConvertCToJava (CIMDateTime*, jint, dt);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetimeempty

(JNIEnv *jEnv, jobject jThs) {

(JNIEnv *jEnv, jobject jThs)

{

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

return (jint)dt;

return DEBUG_ConvertCToJava (CIMDateTime*, jint, dt);

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1after

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

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

CIMDateTime *ct = (CIMDateTime *) jC;

{

CIMDateTime *dt = (CIMDateTime *) 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) {

(JNIEnv *jEnv, jobject jThs, jint jDT)

CIMDateTime *cdt = (CIMDateTime *) jDT;

{

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

delete cdt;

}

DEBUG_ConvertCleanup (jint, jDT);

}

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

// ---

Line 2400

Line 2867

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1getType

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

(JNIEnv *jEnv, jobject jThs, jint jM)

CIMMethod *cm=(CIMMethod*)jM;

{

return (jint)cm->getType();

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

(JNIEnv *jEnv, jobject jThs, jint jM)

CIMMethod *cm=(CIMMethod*)jM;

{

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

delete cm;

}

DEBUG_ConvertCleanup (jint, jM);

}

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

// ---

Line 2420

Line 2892

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byte

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

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

{

CIMValue *cv=NULL;

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

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

if (notSigned)

return (jint)cv;

cv=new CIMValue((Uint8)jb);

else

cv=new CIMValue((Sint8)jb);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1short

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

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

{

CIMValue *cv=NULL;

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

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

if (notSigned)

return (jint)cv;

cv=new CIMValue((Uint16)js);

else

cv=new CIMValue((Sint16)js);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue_makeInt

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

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

{

CIMValue *cv=NULL;

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

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

if (notSigned)

return (jint)cv;

cv = new CIMValue((Uint32)ji);

else

cv = new CIMValue((Sint32)ji);

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1long

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

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

{

CIMValue *cv=NULL;

if (notSigned) cv=new CIMValue((Uint64)jl);

else cv=new CIMValue((Sint64)jl);

if (notSigned)

return (jint)cv;

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

(JNIEnv *jEnv, jobject jThs, jfloat jF)

{

CIMValue *cv=new CIMValue(jF);

return (jint)cv;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1double

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

(JNIEnv *jEnv, jobject jThs, jdouble jD)

{

CIMValue *cv=new CIMValue(jD);

return (jint)cv;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1string

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

(JNIEnv *jEnv, jobject jThs, jstring jS)

{

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

CIMValue *cv=new CIMValue(String(str));

jEnv->ReleaseStringUTFChars(jS,str);

return (jint)cv;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1ref

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

(JNIEnv *jEnv, jobject jThs, jint jR)

CIMObjectPath *ref=(CIMObjectPath*)jR;

{

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

CIMValue *cv=new CIMValue(*ref);

return (jint)cv;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1datetime

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

(JNIEnv *jEnv, jobject jThs, jint jDT)

CIMDateTime *dt=(CIMDateTime*)jDT;

{

CIMDateTime *dt = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jDT);

CIMValue *cv=new CIMValue(*dt);

return (jint)cv;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMValue__1isArray

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

(JNIEnv *jEnv, jobject jThs, jint jP)

CIMValue *cv=(CIMValue*)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) {

(JNIEnv *jEnv, jobject jThs, jboolean jB)

{

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

return (jint)cv;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byteArray

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

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

{

CIMValue *cv=NULL;

jboolean b;

jsize len=jEnv->GetArrayLength(jshortA);

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

if (notSigned) {

Array<Uint8> u8;

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

Line 2515

Line 3024

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

cv=new CIMValue(s8);

}

return (jint)(void*)cv;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1shortArray

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

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

{

CIMValue *cv=NULL;

jboolean b;

jsize len=jEnv->GetArrayLength(jintA);

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

if (notSigned) {

Array<Uint16> u16;

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

Line 2536

Line 3048

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

cv=new CIMValue(s16);

}

return (jint)(void*)cv;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1intArray

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

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

{

CIMValue *cv=NULL;

jboolean b;

jsize len=jEnv->GetArrayLength(jlongA);

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

if (notSigned) {

Array<Uint32> u32;

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

Line 2557

Line 3072

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

cv=new CIMValue(s32);

}

return (jint)(void*)cv;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1longArray

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

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

{

CIMValue *cv=NULL;

jboolean b;

jsize len=jEnv->GetArrayLength(jlongA);

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

if (notSigned) {

Array<Uint64> u64;

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

Line 2578

Line 3096

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

cv=new CIMValue(s64);

}

return (jint)(void*)cv;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1stringArray

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

(JNIEnv *jEnv, jobject jThs, jobjectArray jstringA)

{

CIMValue *cv=NULL;

jboolean b;

jsize len=jEnv->GetArrayLength(jstringA);

Line 2596

Line 3116

}

cv=new CIMValue(strA);

return (jint)(void*)cv;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1booleanArray

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

(JNIEnv *jEnv, jobject jThs, jbooleanArray jboolA)

{

CIMValue *cv=NULL;

jboolean b;

jsize len=jEnv->GetArrayLength(jboolA);

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

Array<Boolean> bA;

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

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

cv=new CIMValue(bA);

return (jint)(void*)cv;

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1refArray

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

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

return DEBUG_ConvertCToJava (CIMValue*, jint, cv);

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType

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

(JNIEnv *jEnv, jobject jThs, jint jP)

CIMValue *cv=(CIMValue*)jP;

{

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

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

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

}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString

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

(JNIEnv *jEnv, jobject jThs, jint jV)

CIMValue *cv=(CIMValue*)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) {

(JNIEnv *jEnv, jobject jThs, jint jV)

CIMValue *cv=(CIMValue*)jV;

{

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

if (cv->isNull())

return NULL;

CIMType type=cv->getType();

if (!cv->isArray()) {

Line 2714

Line 3248

case CIMTYPE_REFERENCE: {

CIMObjectPath ref;

cv->get(ref);

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

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

(jint)new CIMObjectPath(ref));

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

}

break;

case CIMTYPE_CHAR16:

Line 2724

Line 3258

case CIMTYPE_DATETIME: {

CIMDateTime dt;

cv->get(dt);

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

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

(jint)new CIMDateTime(dt));

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

}

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

break;

case CIMTYPE_OBJECT:

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

Line 2736

Line 3269

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

}

else {

switch (type) {

case CIMTYPE_BOOLEAN: {

Line 2868

Line 3400

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

}

return NULL;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMValue__1finalize

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

(JNIEnv *jEnv, jobject jThs, jint jV)

CIMValue *cv=(CIMValue*)jV;

{

if (cv) delete cv;

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

}

delete cv;

DEBUG_ConvertCleanup (jint, jV);

}

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

// ---

Line 2911

Line 3447

}

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

if (p>=0) {

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

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

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

hostName_.remove(p);

}

Line 2929

Line 3465

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1new

(JNIEnv *jEnv, jobject jThs) {

(JNIEnv *jEnv, jobject jThs)

return (jint)(void*) new _nameSpace();

{

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

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHn

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

(JNIEnv *jEnv, jobject jThs, jstring jHn)

{

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

jint cInst=(jint)(void*)new _nameSpace(hn);

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

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

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

(JNIEnv *jEnv, jobject jThs, jint jNs)

_nameSpace *cNs=(_nameSpace*)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) {

(JNIEnv *jEnv, jobject jThs, jint jNs)

_nameSpace *cNs=(_nameSpace*)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) {

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

_nameSpace *cNs=(_nameSpace*)jNs;

{

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

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

_nameSpace *cNs=(_nameSpace*)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);

}

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

// ---

Line 2992

Line 3552

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1getClass

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) {

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)

Array<CIMClass> *enm=(Array<CIMClass>*)jEnum;

{

return (jint) new CIMClass((*enm)[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) {

(JNIEnv *jEnv, jobject jThs, jint jEnum)

Array<CIMClass> *enm=(Array<CIMClass>*)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) {

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)

Array<CIMInstance> *enm=(Array<CIMInstance>*)jEnum;

{

return (jint) new CIMInstance((*enm)[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) {

(JNIEnv *jEnv, jobject jThs, jint jEnum)

Array<CIMInstance> *enm=(Array<CIMInstance>*)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) {

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)

Array<CIMObjectPath> *enm=(Array<CIMObjectPath>*)jEnum;

{

return (jint) new CIMObjectPath((*enm)[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) {

(JNIEnv *jEnv, jobject jThs, jint jEnum)

Array<CIMObjectPath> *enm=(Array<CIMObjectPath>*)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) {

(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)

Array<CIMQualifierDecl> *enm=(Array<CIMQualifierDecl>*)jEnum;

{

return (jint) new CIMQualifierDecl((*enm)[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) {

(JNIEnv *jEnv, jobject jThs, jint jEnum)

Array<CIMQualifierDecl> *enm=(Array<CIMQualifierDecl>*)jEnum;

{

Array<CIMQualifierDecl> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMQualifierDecl>*, jEnum);

return enm->size();

}

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

// ---

// - CIMClient

Line 3057

Line 3630

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1newNaUnPw

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

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

_nameSpace *cNs=(_nameSpace*)jNs;

{

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

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

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

Line 3069

Line 3643

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

jEnv->ReleaseStringUTFChars(jUn,un);

jEnv->ReleaseStringUTFChars(jPw,pw);

return (jint)(void*)cc;

return DEBUG_ConvertCToJava (CIMClient*, jint, cc);

}

Catch(jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1disconnect

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

(JNIEnv *jEnv, jobject jThs, jint jCc)

CIMClient *cCc=(CIMClient*)jCc;

{

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

try {

cCc->disconnect();

}

Line 3086

Line 3662

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

jboolean iq, jboolean ic, jobjectArray jPl)

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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 (jint) new CIMClass(cls);

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)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);

return;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createClass

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

CIMClass *cl=(CIMClass*)jCl;

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

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

try {

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

}

Catch(jEnv);

return;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setClass

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

CIMClass *cl=(CIMClass*)jCl;

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

return ;

}

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

(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, int jCop, jboolean deep, jboolean lo, jboolean iq, jboolean ic)

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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 (jint) new Array<CIMClass>(enm);

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

Line 3165

Line 3750

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

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

}

return (jint)enmop;

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)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());

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

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

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

jboolean iq, jboolean ic, jobjectArray jPl)

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

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

return (jint) new CIMInstance(inst);

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)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);

return;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1createInstance

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

CIMInstance *ci=(CIMInstance*)jCi;

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 (jint) new CIMObjectPath(obj);

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

jboolean iq, jobjectArray jPl)

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

CIMInstance *ci=(CIMInstance*)jCi;

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

return ;

}

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

jboolean iq, jboolean ic, jobjectArray jPl)

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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 (jint) new Array<CIMInstance>(enm);

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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 (jint) new Array<CIMObjectPath>(enm);

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)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 (jint)val;

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)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);

return;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setQualifier

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

CIMQualifierDecl *qt=(CIMQualifierDecl*)jQ;

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

return;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

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

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

CIMName pName(str);

jEnv->ReleaseStringUTFChars(jPn,str);

try {

checkNs(cop,jNs);

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

return (jint)val;

return DEBUG_ConvertCToJava (CIMValue*, jint, val);

}

Catch(jEnv);

return 0;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

CIMValue *val=(CIMValue*)jCop;

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

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

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

CIMName pName(str);

jEnv->ReleaseStringUTFChars(jPn,str);

try {

checkNs(cop,jNs);

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

}

Catch(jEnv);

return;

}

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

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

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

CIMName method(str);

jEnv->ReleaseStringUTFChars(jMn,str);

Array<CIMParamValue> in;

Line 3363

Line 3981

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

JMPIjvm::checkException(jEnv);

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

JMPIjvm::checkException(jEnv);

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

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

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

JMPIjvm::checkException(jEnv);

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

}

try {

Line 3377

Line 4000

const CIMParamValue & parm=out[i];

const CIMValue v=parm.getValue();

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

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

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

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

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

}

return (jint)val;

return DEBUG_ConvertCToJava (CIMValue*, jint, val);

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod24

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

jobjectArray jIn, jobjectArray jOut) {

jobjectArray jIn, jobjectArray jOut)

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

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

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

CIMName method(str);

jEnv->ReleaseStringUTFChars(jMn,str);

Array<CIMParamValue> in;

Line 3400

Line 4029

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

JMPIjvm::checkException(jEnv);

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

JMPIjvm::checkException(jEnv);

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

jint jp = jEnv->CallIntMethod(jArg,instanceMethodIDs[39]);

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

JMPIjvm::checkException(jEnv);

in.append(*p);

}

try {

Line 3411

Line 4045

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

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

const CIMParamValue & parm=out[i];

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

jEnv->SetObjectArrayElement(jOut,i,

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

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

jEnv->SetObjectArrayElement(jOut,

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

}

return (jint)val;

return DEBUG_ConvertCToJava (CIMValue*, jint, val);

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

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

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

String query(str);

/* Note:

** This does not work for some reason on the client java code:

Line 3434

Line 4074

** printf ("This is a test\n");

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

String query(str);

jEnv->ReleaseStringUTFChars(jQuery,str);

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

Line 3446

Line 4083

try {

checkNs(cop,jNs);

Array<CIMObject> enm=cCc->execQuery(

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

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;

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

}

Catch(jEnv);

return 0;

}

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

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 {

checkNs(cop,jNs);

Array<CIMObjectPath> enm=cCc->associatorNames(

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

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

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

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associators

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

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

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl) {

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

Line 3517

Line 4169

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

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

}

return (jint)enmInst;

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

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1referenceNames

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

jstring jAssocClass, jstring jRole) {

jstring jAssocClass, jstring jRole)

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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 {

checkNs(cop,jNs);

Array<CIMObjectPath> enm=cCc->referenceNames(

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

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

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

}

Catch(jEnv);

return 0;

}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1references

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

jstring jAssocClass, jstring jRole,

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl) {

jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)

CIMClient *cCc=(CIMClient*)jCc;

{

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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 {

Line 3570

Line 4230

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

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

}

return (jint)enmInst;

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

}

Catch(jEnv);

return 0;

}

Line 3594

Line 4255

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createNameSpace

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

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

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

String ns(str);

jEnv->ReleaseStringUTFChars(jNs,str);

String lastNsComp;

Line 3613

Line 4275

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

}

Catch(jEnv);

return;

}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateNameSpaces

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

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

{

CIMClient *cCc=(CIMClient*)jCc;

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

CIMObjectPath *cop=(CIMObjectPath*)jCop;

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

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

try {

Array<CIMObjectPath> enm=cCc->enumerateInstanceNames(

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

Line 3637

Line 4299

}

Catch(jEnv);

return jVec;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteNameSpace

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

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

CIMClient *cCc=(CIMClient*)jCc;

{

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;

Line 3661

Line 4326

cCc->deleteInstance(CIMNamespaceName(nsBase),cop);

}

Catch(jEnv);

return;

}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1finalize

(JNIEnv *jEnv, jobject jThs, jint jCc)

{

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

delete cCc;

DEBUG_ConvertCleanup (jint, jCc);

}

} // extern "C"

Legend:

Removed from v.1.19
changed lines
	Added in v.1.25

No CVS admin address has been configured