version 1.1, 2004/04/30 10:27:25
|
version 1.14, 2005/03/17 01:56:13
|
|
|
//%2003//////////////////////////////////////////////////////////////////////// |
//%2005//////////////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Development |
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
// Company, L. P., IBM Corp., The Open Group, Tivoli Systems. |
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. |
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; | // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; |
// IBM Corp.; EMC Corporation, The Open Group. | // IBM Corp.; EMC Corporation, The Open Group. |
|
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; |
|
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
|
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; VERITAS Software Corporation; The Open Group. |
// | // |
// Permission is hereby granted, free of charge, to any person obtaining a copy | // Permission is hereby granted, free of charge, to any person obtaining a copy |
// of this software and associated documentation files (the "Software"), to | // of this software and associated documentation files (the "Software"), to |
|
|
| |
#include "JMPIImpl.h" | #include "JMPIImpl.h" |
| |
|
#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC) |
|
#include <Pegasus/Common/DynamicLibrary.h> |
|
#else |
#include <dlfcn.h> | #include <dlfcn.h> |
|
#endif |
#include <iostream> | #include <iostream> |
| |
#include <Pegasus/Common/Config.h> | #include <Pegasus/Common/Config.h> |
|
|
#include <Pegasus/Common/OperationContext.h> | #include <Pegasus/Common/OperationContext.h> |
#include <Pegasus/Provider/CIMOMHandle.h> | #include <Pegasus/Provider/CIMOMHandle.h> |
#include <Pegasus/Client/CIMClient.h> | #include <Pegasus/Client/CIMClient.h> |
|
#include <Pegasus/ProviderManager2/JMPI/JMPIProviderManager.h> |
| |
PEGASUS_USING_STD; | PEGASUS_USING_STD; |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
JavaVM *JMPIjvm::jvm=NULL; | JavaVM *JMPIjvm::jvm=NULL; |
JvmVector JMPIjvm::jv; | JvmVector JMPIjvm::jv; |
|
int JMPIjvm::trace=0; |
| |
typedef struct { | typedef struct { |
int clsIndex; | int clsIndex; |
|
|
"java/lang/String", // 22 | "java/lang/String", // 22 |
"org/pegasus/jmpi/JarClassLoader", // 23 | "org/pegasus/jmpi/JarClassLoader", // 23 |
"org/pegasus/jmpi/CIMDateTime", // 24 | "org/pegasus/jmpi/CIMDateTime", // 24 |
|
"org/pegasus/jmpi/SelectExp", // 25 |
|
"org/pegasus/jmpi/CIMQualifier", // 26 |
|
"org/pegasus/jmpi/CIMQualifierType",// 27 |
|
"org/pegasus/jmpi/CIMFlavor", // 28 |
|
"org/pegasus/jmpi/CIMArgument", // 29 |
|
"org/pegasus/jmpi/CIMInstanceException", // 30 |
}; | }; |
| |
| |
|
|
/*15*/ { 0, "addElement", "(Ljava/lang/Object;)V" }, | /*15*/ { 0, "addElement", "(Ljava/lang/Object;)V" }, |
| |
/*16*/ { 0, "elementAt", "(I)Ljava/lang/Object;" }, | /*16*/ { 0, "elementAt", "(I)Ljava/lang/Object;" }, |
/*17*/ { 16,"<init>", "(I)V" }, |
/*17*/ { 16,"<init>", "(ILjava/lang/String;)V" }, |
/*18*/ { 13,"<init>", "(I)V" }, | /*18*/ { 13,"<init>", "(I)V" }, |
/*19*/ { 17,"<init>", "(I)V" }, | /*19*/ { 17,"<init>", "(I)V" }, |
/*20*/ { 18,"<init>", "(I)V" }, | /*20*/ { 18,"<init>", "(I)V" }, |
|
|
/*32*/ { 19,"cInst", "()I" }, | /*32*/ { 19,"cInst", "()I" }, |
/*33*/ { 13,"<init>", "(ILjava/lang/String;)V" }, | /*33*/ { 13,"<init>", "(ILjava/lang/String;)V" }, |
/*34*/ { 13,"getCode", "()I" }, | /*34*/ { 13,"getCode", "()I" }, |
/*35*/ { 12,"<init>", "(I)V" }, |
/*35*/ { 24,"<init>", "(I)V" }, |
|
/*36*/ { 25,"<init>", "(I)V" }, |
|
/*37*/ { 26,"<init>", "(I)V" }, |
|
/*38*/ { 28,"<init>", "(I)V" }, |
|
/*38*/ { 28,"getFlavor", "()I" }, |
|
/*39*/ { 29,"cInst", "()I" }, |
|
/*40*/ { 29,"<init>", "(I)V" }, |
|
/*41*/ { 13,"<init>", "()V" }, |
|
/*42*/ { 13,"<init>", "(Ljava/lang/String;)V" }, |
|
/*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" }, |
}; | }; |
| |
const METHOD_STRUCT staticMethodNames[]={ | const METHOD_STRUCT staticMethodNames[]={ |
|
|
} | } |
| |
int JMPIjvm::cacheIDs(JNIEnv *env) { | int JMPIjvm::cacheIDs(JNIEnv *env) { |
|
if (JMPIjvm::trace) |
|
cout<<" --- cacheIDs()"<<endl; |
if (methodInitDone==1) return JNI_TRUE; | if (methodInitDone==1) return JNI_TRUE; |
if (methodInitDone==-1) return JNI_FALSE; | if (methodInitDone==-1) return JNI_FALSE; |
| |
|
|
staticMethodNames[k].methodName,staticMethodNames[k].signature))==NULL) return 0; | staticMethodNames[k].methodName,staticMethodNames[k].signature))==NULL) return 0; |
} | } |
// cerr<<"--- cacheIDs() done"<<endl; | // cerr<<"--- cacheIDs() done"<<endl; |
|
if (JMPIjvm::trace) |
|
cout<<" --- cacheIDs() ok"<<endl; |
methodInitDone=1; | methodInitDone=1; |
return JNI_TRUE; | return JNI_TRUE; |
} | } |
|
|
env->ThrowNew(classRefs[13],e); | env->ThrowNew(classRefs[13],e); |
} | } |
| |
|
int JMPIjvm::destroyJVM() |
|
{ |
|
if (JMPIjvm::trace) |
|
cerr<<"--- JPIjvm::destroyJVM()\n"; |
|
#ifdef JAVA_DESTROY_VM_WORKS |
|
if (jvm!=NULL) { |
|
JvmVector *jv; |
|
attachThread(&jv); |
|
jvm->DestroyJavaVM(); |
|
jvm=NULL; |
|
return 0; |
|
} |
|
#endif |
|
return -1; |
|
} |
|
|
int JMPIjvm::initJVM() | int JMPIjvm::initJVM() |
{ | { |
JavaVMInitArgs vm_args; | JavaVMInitArgs vm_args; |
|
|
char classpath[1024]="-Djava.class.path="; | char classpath[1024]="-Djava.class.path="; |
JNIEnv *env; | JNIEnv *env; |
| |
std::cerr<<"--- JPIjvm::initJVM()\n"; |
|
|
#ifdef PEGASUS_DEBUG |
|
if (getenv("JMPI_TRACE")) trace=1; |
|
else trace=0; |
|
#else |
|
trace=0; |
|
#endif |
|
|
|
if (JMPIjvm::trace) |
|
cout<<"--- JPIjvm::initJVM()\n"; |
jv.initRc=0; | jv.initRc=0; |
| |
envcp=getenv("CLASSPATH"); | envcp=getenv("CLASSPATH"); |
if (envcp==NULL) { | if (envcp==NULL) { |
jv.initRc=1; | jv.initRc=1; |
std::cerr<<"--- jmpiJvm::initJVM(): No PEGASUS_PROVIDER_CLASSPATH environment variable found\n"; |
if (JMPIjvm::trace) |
|
cerr<<"--- jmpiJvm::initJVM(): No PEGASUS_PROVIDER_CLASSPATH environment variable found\n"; |
return -1; | return -1; |
} | } |
| |
|
|
| |
res=JNI_CreateJavaVM(&jvm,(void**)&env,&vm_args); | res=JNI_CreateJavaVM(&jvm,(void**)&env,&vm_args); |
if (res!=0) { | if (res!=0) { |
fprintf(stderr,"Can not create Java VM\n"); |
if (JMPIjvm::trace) |
|
cerr<<"Can not create Java VM"<<endl; |
exit(1); | exit(1); |
} | } |
jv.jvm=jvm; | jv.jvm=jvm; |
|
|
if (cacheIDs(env)==1) { | if (cacheIDs(env)==1) { |
jv.classRefs=classRefs; | jv.classRefs=classRefs; |
jv.instMethodIDs=instanceMethodIDs; | jv.instMethodIDs=instanceMethodIDs; |
// jv.classMethodIDs=classMethodIDs; |
|
} | } |
| |
if (env->ExceptionOccurred()) { | if (env->ExceptionOccurred()) { |
|
|
exit(1); | exit(1); |
} | } |
| |
// dlopen("libjmpiVM.so",RTLD_NOW); |
|
// std::cerr<<"--- JPIjvm::initJVM(): selfloading done\n"; |
|
|
|
return res; | return res; |
} | } |
| |
|
|
} | } |
| |
/* | /* |
std::cout<<"--- jar: "<<jar<<std::endl; |
cout<<"--- jar: "<<jar<<endl; |
std::cout<<"--- cln: "<<cln<<std::endl; |
cout<<"--- cln: "<<cln<<endl; |
| |
jstring jjar=env->NewStringUTF((const char*)jar.getCString()); | jstring jjar=env->NewStringUTF((const char*)jar.getCString()); |
jstring jcln=env->NewStringUTF((const char*)cln.getCString()); | jstring jcln=env->NewStringUTF((const char*)cln.getCString()); |
|
|
jjar,jcln); | jjar,jcln); |
if (env->ExceptionCheck()) { | if (env->ExceptionCheck()) { |
env->ExceptionDescribe(); | env->ExceptionDescribe(); |
std::cerr<<"--- Unable to instantiate provider "<<cn<<std::endl; |
cerr<<"--- Unable to instantiate provider "<<cn<<endl; |
// return NULL; | // return NULL; |
} | } |
*/ | */ |
| |
scls=getGlobalClassRef(env,(const char*)cln.getCString()); | scls=getGlobalClassRef(env,(const char*)cln.getCString()); |
if (env->ExceptionCheck()) { | if (env->ExceptionCheck()) { |
std::cerr<<"--- Provider "<<cn<<" not found"<<std::endl; |
if (JMPIjvm::trace) |
|
cerr<<"--- Provider "<<cn<<" not found"<<endl; |
return NULL; | return NULL; |
} | } |
*cls=scls; | *cls=scls; |
|
|
jobject lProv=env->NewObject(*cls,id); | jobject lProv=env->NewObject(*cls,id); |
gProv=(jobject)env->NewGlobalRef(lProv); | gProv=(jobject)env->NewGlobalRef(lProv); |
if (env->ExceptionCheck()) { | if (env->ExceptionCheck()) { |
std::cerr<<"--- Unable to instantiate provider "<<cn<<std::endl; |
if (JMPIjvm::trace) |
|
cerr<<"--- Unable to instantiate provider "<<cn<<endl; |
return NULL; | return NULL; |
} | } |
return gProv; | return gProv; |
|
|
| |
scls=getGlobalClassRef(env,cn); | scls=getGlobalClassRef(env,cn); |
if (env->ExceptionCheck()) { | if (env->ExceptionCheck()) { |
std::cerr<<"--- Provider "<<cn<<" not found"<<std::endl; |
if (JMPIjvm::trace) |
|
cerr<<"--- Provider "<<cn<<" not found"<<endl; |
return NULL; | return NULL; |
} | } |
*cls=scls; | *cls=scls; |
|
|
jobject lProv=env->NewObject(*cls,id); | jobject lProv=env->NewObject(*cls,id); |
gProv=(jobject)env->NewGlobalRef(lProv); | gProv=(jobject)env->NewGlobalRef(lProv); |
if (env->ExceptionCheck()) { | if (env->ExceptionCheck()) { |
std::cerr<<"--- Unable to instantiate provider "<<cn<<std::endl; |
if (JMPIjvm::trace) |
|
cerr<<"--- Unable to instantiate provider "<<cn<<endl; |
return NULL; | return NULL; |
} | } |
return gProv; | return gProv; |
|
|
| |
void JMPIjvm::checkException(JNIEnv *env) | void JMPIjvm::checkException(JNIEnv *env) |
{ | { |
jstring msg=NULL,id=NULL; |
|
|
if (env->ExceptionCheck()) { |
|
jstring jMsg=NULL,jId=NULL; |
int code; | int code; |
const char *cp; | const char *cp; |
char hcp[512]="",hcp1[128]; |
String msg=String::EMPTY,id=String::EMPTY; |
String m=String::EMPTY; |
|
| |
if (env->ExceptionCheck()) { |
|
jthrowable err=env->ExceptionOccurred(); | jthrowable err=env->ExceptionOccurred(); |
// env->ExceptionDescribe(); |
if (JMPIjvm::trace) |
|
env->ExceptionDescribe(); |
|
if (env->IsInstanceOf(err,JMPIjvm::jv.CIMExceptionClassRef)) { |
env->ExceptionClear(); | env->ExceptionClear(); |
if (err) { | if (err) { |
msg=(jstring)env->CallObjectMethod(err,JMPIjvm::jv.ThrowableGetMessage); |
jMsg=(jstring)env->CallObjectMethod(err,JMPIjvm::jv.ThrowableGetMessage); |
code=(int)env->CallObjectMethod(err,JMPIjvm::jv.CIMExceptionGetCode); |
code=(int)env->CallIntMethod(err,JMPIjvm::jv.CIMExceptionGetCode); |
id=(jstring)env->CallObjectMethod(err,JMPIjvm::jv.CIMExceptionGetID); |
jId=(jstring)env->CallObjectMethod(err,JMPIjvm::jv.CIMExceptionGetID); |
if (id) { |
if (jId) { |
const char *cp=env->GetStringUTFChars(id,NULL); |
cp=env->GetStringUTFChars(jId,NULL); |
strncpy(hcp1,cp,511); |
id=String(cp); |
env->ReleaseStringUTFChars(id,cp); |
env->ReleaseStringUTFChars(jId,cp); |
} |
} |
|
|
if (msg) { |
if (jMsg) { |
const char *cp=env->GetStringUTFChars(msg,NULL); |
cp=env->GetStringUTFChars(jMsg,NULL); |
strncpy(hcp,cp,511); |
msg=String(cp); |
env->ReleaseStringUTFChars(msg,cp); |
env->ReleaseStringUTFChars(jMsg,cp); |
m=String(hcp); |
} |
|
if (JMPIjvm::trace) |
|
cerr<<"--- throwing Pegasus exception: "<<code<<" "<<id<<" ("<<msg<<")"<<endl; |
|
throw CIMException((CIMStatusCode)code,id+" ("+msg+")"); |
} | } |
// std::cerr<<"--- exception: "<<hcp1<<" ("<<hcp<<") "<<std::endl; |
} |
throw CIMException((CIMStatusCode)code,m); |
else { |
|
env->ExceptionDescribe(); |
|
exit(13); |
} | } |
} | } |
} | } |
|
|
} | } |
| |
| |
|
|
|
|
|
// ------------------------------------- |
|
// --- |
|
// - CIMException |
|
// --- |
|
// ------------------------------------- |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1new |
|
(JNIEnv *jEnv, jobject jThs) { |
|
jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[41]); |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newS |
|
(JNIEnv *jEnv, jobject jThs, jstring jM) { |
|
jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[42],jM); |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSO |
|
(JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1) { |
|
jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[43],jM,jO1); |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSOO |
|
(JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1, jobject jO2) { |
|
jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[44],jM,jO1,jO2); |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSOOO |
|
(JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1, jobject jO2, jobject jO3) { |
|
jEnv->CallNonvirtualVoidMethod(jThs,classRefs[13],instanceMethodIDs[45],jM,jO1,jO2,jO3); |
|
} |
|
|
|
|
|
|
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
// - CIMOMHandle | // - CIMOMHandle |
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
|
CIMPropertyList getList(JNIEnv *jEnv, jobjectArray l) { |
|
CIMPropertyList pl; |
|
if (l) { |
|
Array<CIMName> n; |
|
for (jsize i=0,s=jEnv->GetArrayLength(l); i<s; i++) { |
|
jstring jObj=(jstring)jEnv->GetObjectArrayElement(l,i); |
|
const char *pn=jEnv->GetStringUTFChars(jObj,NULL); |
|
n.append(pn); |
|
jEnv->ReleaseStringUTFChars(jObj,pn); |
|
} |
|
pl.set(n); |
|
} |
|
return pl; |
|
} |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getClass | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getClass |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean lo) { |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean lo, |
|
jboolean iq, jboolean ic, jobjectArray jPl) { |
CIMOMHandle *ch=(CIMOMHandle*)jCh; | CIMOMHandle *ch=(CIMOMHandle*)jCh; |
CIMObjectPath *cop=(CIMObjectPath*)jCop; | CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMPropertyList pl; |
OperationContext ctx; | OperationContext ctx; |
|
if (jPl) pl=getList(jEnv,jPl); |
|
else pl=CIMPropertyList(); |
try { | try { |
CIMClass cc=ch->getClass(ctx,cop->getNameSpace(),cop->getClassName(), |
CIMClass cls=ch->getClass(ctx,cop->getNameSpace(),cop->getClassName(),(Boolean)lo, |
(Boolean)lo, |
(Boolean)iq,(Boolean)ic,pl); |
true,true,CIMPropertyList()); |
return (jint) new CIMClass(cls); |
return (jint)new CIMClass(cc); |
|
} | } |
Catch(jEnv); | Catch(jEnv); |
return 0; | return 0; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumClass |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createClass |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean lo, jobject jVec) { |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, int jCl) { |
CIMOMHandle *ch=(CIMOMHandle*)jCh; | CIMOMHandle *ch=(CIMOMHandle*)jCh; |
CIMObjectPath *cop=(CIMObjectPath*)jCop; | CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMClass *cl=(CIMClass*)jCl; |
OperationContext ctx; | OperationContext ctx; |
try { | try { |
Array<CIMClass> en=ch->enumerateClasses(ctx,cop->getNameSpace(),cop->getClassName(), |
ch->createClass(ctx,cop->getNameSpace(),*cl); |
true,(Boolean)lo,true,true); |
|
if (!cop->getClassName().isNull()) |
|
en.append(ch->getClass(ctx,cop->getNameSpace(),cop->getClassName(),(Boolean)lo, |
|
true,true,CIMPropertyList())); |
|
for (int i=0,m=en.size(); i<m; i++) { |
|
CIMClass *cls=new CIMClass(en[i]); |
|
jobject jCls=jEnv->NewObject(classRefs[17],instanceMethodIDs[19],(jint)cls); |
|
jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],jCls); |
|
} | } |
|
Catch(jEnv); |
return; | return; |
} | } |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setClass |
|
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCl) { |
|
CIMOMHandle *ch=(CIMOMHandle*)jCh; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMClass *cl=(CIMClass*)jCl; |
|
OperationContext ctx; |
|
try { |
|
ch->modifyClass(ctx,cop->getNameSpace(),*cl); |
|
} |
Catch(jEnv); | Catch(jEnv); |
return; | return; |
} | } |
| |
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteClass |
|
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop) { |
|
|
|
CIMOMHandle *ch=(CIMOMHandle*)jCh; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
OperationContext ctx; |
|
|
|
try { |
|
ch->deleteClass(ctx,cop->getNameSpace(),cop->getClassName()); |
|
} |
|
Catch(jEnv); |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClassNames |
|
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean deep) { |
|
CIMOMHandle *ch=(CIMOMHandle*)jCh; |
|
CIMObjectPath *cop=(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; |
|
} |
|
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) { |
|
CIMOMHandle *ch=(CIMOMHandle*)jCh; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
OperationContext ctx; |
|
try { |
|
Array<CIMClass> en=ch->enumerateClasses(ctx,cop->getNameSpace(),cop->getClassName(), |
|
deep,(Boolean)lo,iq,ic); |
|
return (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) { |
|
|
|
CIMOMHandle *ch=(CIMOMHandle*)jCh; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
OperationContext ctx; |
|
CIMPropertyList pl; |
|
if (jPl) pl=getList(jEnv,jPl); |
|
else pl=CIMPropertyList(); |
|
try { |
|
CIMInstance *inst=new CIMInstance(ch->getInstance(ctx,cop->getNameSpace(),*cop, |
|
(Boolean)lo,(Boolean)iq,(Boolean)ic,pl)); |
|
return (jint)(void*)inst; |
|
} |
|
Catch(jEnv); |
|
return -1; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance |
|
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop) { |
|
|
|
CIMOMHandle *ch=(CIMOMHandle*)jCh; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
OperationContext ctx; |
|
|
|
try { |
|
ch->deleteInstance(ctx,cop->getNameSpace(),*cop); |
|
} |
|
Catch(jEnv); |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createInstance |
|
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, int jCi) { |
|
CIMOMHandle *ch=(CIMOMHandle*)jCh; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMInstance *ci=(CIMInstance*)jCi; |
|
OperationContext ctx; |
|
try { |
|
ci->setPath(*cop); |
|
CIMObjectPath obj=ch->createInstance(ctx,cop->getNameSpace(),*ci); |
|
return (jint) new CIMObjectPath(obj); |
|
} |
|
Catch(jEnv); |
|
return 0; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1modifyInstance |
|
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCi, |
|
jboolean iq, jobjectArray jPl) { |
|
CIMOMHandle *ch=(CIMOMHandle*)jCh; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMInstance *ci=(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) { |
|
CIMOMHandle *ch=(CIMOMHandle*)jCh; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
OperationContext ctx; |
|
try { |
|
Array<CIMObjectPath> enm=ch->enumerateInstanceNames(ctx, |
|
cop->getNameSpace(),cop->getClassName()); //,(Boolean)deep); |
|
return (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) { |
|
CIMOMHandle *ch=(CIMOMHandle*)jCh; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMPropertyList pl; |
|
OperationContext ctx; |
|
if (jPl) pl=getList(jEnv,jPl); |
|
else pl=CIMPropertyList(); |
|
try { |
|
Array<CIMInstance> en=ch->enumerateInstances(ctx,cop->getNameSpace(),cop->getClassName(), |
|
deep,lo,iq,ic,pl); |
|
return (jint) new Array<CIMInstance>(en); |
|
} |
|
Catch(jEnv); |
|
return 0; |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1execQuery |
|
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jQuery, jstring jQl) { |
|
CIMOMHandle *ch=(CIMOMHandle*)jCh; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
OperationContext ctx; |
|
|
|
const char *str=jEnv->GetStringUTFChars(jQuery,NULL); |
|
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<CIMInstance> *enmInst=new Array<CIMInstance>(); |
|
for (int i=0,m=enm.size(); i<m; i++) { |
|
enmInst->append(CIMInstance(enm[i])); |
|
} |
|
return (jint)enmInst; |
|
} |
|
Catch(jEnv); |
|
return 0; |
|
} |
|
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getProperty | 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; | CIMOMHandle *ch=(CIMOMHandle*)jCh; |
CIMObjectPath *cop=(CIMObjectPath*)jCop; | CIMObjectPath *cop=(CIMObjectPath*)jCop; |
OperationContext ctx; | OperationContext ctx; |
|
|
return -1; | return -1; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setProperty |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop) { |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jPn, jint jV) { |
|
CIMOMHandle *ch=(CIMOMHandle*)jCh; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
OperationContext ctx; |
|
CIMValue *val=(CIMValue*)jCop; |
|
const char *str=jEnv->GetStringUTFChars(jPn,NULL); |
|
CIMName pName(str); |
|
jEnv->ReleaseStringUTFChars(jPn,str); |
|
try { |
|
ch->setProperty(ctx,cop->getNameSpace(),*cop,pName,*val); |
|
} |
|
Catch(jEnv); |
|
return; |
|
} |
|
|
|
|
| |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod |
|
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jMn, jobject jIn, jobject jOut) { |
CIMOMHandle *ch=(CIMOMHandle*)jCh; | CIMOMHandle *ch=(CIMOMHandle*)jCh; |
CIMObjectPath *cop=(CIMObjectPath*)jCop; | CIMObjectPath *cop=(CIMObjectPath*)jCop; |
OperationContext ctx; | OperationContext ctx; |
|
const char *str=jEnv->GetStringUTFChars(jMn,NULL); |
|
CIMName method(str); |
|
jEnv->ReleaseStringUTFChars(jMn,str); |
|
|
|
Array<CIMParamValue> in; |
|
Array<CIMParamValue> out; |
|
|
|
for (int i=0,m=jEnv->CallIntMethod(jIn,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])); |
|
JMPIjvm::checkException(jEnv); |
|
in.append(CIMParamValue(p->getName().getString(),p->getValue())); |
|
} |
|
try { |
|
CIMValue *val=new CIMValue(ch->invokeMethod(ctx,cop->getNameSpace(),*cop,method,in,out)); |
|
|
|
for (int i=0,m=out.size(); i<m; i++) { |
|
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); |
|
jEnv->CallVoidMethod(jOut,instanceMethodIDs[15],prop); |
|
} |
|
return (jint)val; |
|
} |
|
Catch(jEnv); |
|
return 0; |
|
} |
| |
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod24 |
|
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jMn, |
|
jobjectArray jIn, jobjectArray jOut) { |
|
CIMOMHandle *ch=(CIMOMHandle*)jCh; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
OperationContext ctx; |
|
const char *str=jEnv->GetStringUTFChars(jMn,NULL); |
|
CIMName method(str); |
|
jEnv->ReleaseStringUTFChars(jMn,str); |
|
|
|
Array<CIMParamValue> in; |
|
Array<CIMParamValue> out; |
|
|
|
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])); |
|
JMPIjvm::checkException(jEnv); |
|
in.append(*p); |
|
} |
try { | try { |
ch->deleteInstance(ctx,cop->getNameSpace(),*cop); |
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]; |
|
jEnv->SetObjectArrayElement(jOut,i, |
|
jEnv->NewObject(classRefs[29],instanceMethodIDs[40],(jint)&parm)); |
|
} |
|
return (jint)val; |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
return 0; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumInstances |
|
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean jDeep, jboolean jLocalOnly, jobject jVec) { |
|
| |
|
|
|
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) { |
|
CIMOMHandle *ch=(CIMOMHandle*)jCh; |
|
CIMObjectPath *cop=(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); |
|
return (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) { |
CIMOMHandle *ch=(CIMOMHandle*)jCh; | CIMOMHandle *ch=(CIMOMHandle*)jCh; |
CIMObjectPath *cop=(CIMObjectPath*)jCop; | CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMPropertyList pl=getList(jEnv,jPl); |
OperationContext ctx; | 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 { | try { |
Array<CIMInstance> inst=ch->enumerateInstances(ctx,cop->getNameSpace(),cop->getClassName(), |
Array<CIMObject> enm=ch->associators(ctx, |
(Boolean)jDeep,(Boolean)jLocalOnly,true,true,CIMPropertyList()); |
cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole, |
for (int i=0,s=inst.size(); i<s; i++){ |
(Boolean)includeQualifiers,(Boolean)includeClassOrigin,pl); |
CIMInstance *ci=new CIMInstance(inst[i]); |
Array<CIMInstance> *enmInst=new Array<CIMInstance>(); |
jobject jCi=jEnv->NewObject(classRefs[18],instanceMethodIDs[20],(jint)ci); |
for (int i=0,m=enm.size(); i<m; i++) { |
jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],jCi); |
enmInst->append(CIMInstance(enm[i])); |
} | } |
|
return (jint)enmInst; |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
return 0; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getInstance |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1referenceNames |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean jLocalOnly) { |
(JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, |
|
jstring jAssocClass, jstring jRole) { |
|
CIMOMHandle *ch=(CIMOMHandle*)jCh; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
OperationContext ctx; |
|
|
|
const char *str=jEnv->GetStringUTFChars(jAssocClass,NULL); |
|
CIMName assocClass(str); |
|
jEnv->ReleaseStringUTFChars(jAssocClass,str); |
|
str=jEnv->GetStringUTFChars(jRole,NULL); |
|
String role(str); |
|
jEnv->ReleaseStringUTFChars(jRole,str); |
|
|
|
try { |
|
Array<CIMObjectPath> enm=ch->referenceNames(ctx, |
|
cop->getNameSpace(),*cop,assocClass,role); |
|
return (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) { |
CIMOMHandle *ch=(CIMOMHandle*)jCh; | CIMOMHandle *ch=(CIMOMHandle*)jCh; |
CIMObjectPath *cop=(CIMObjectPath*)jCop; | CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMPropertyList pl=getList(jEnv,jPl); |
OperationContext ctx; | 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 { | try { |
CIMInstance *inst=new CIMInstance(ch->getInstance(ctx,cop->getNameSpace(),*cop, |
Array<CIMObject> enm=ch->references(ctx, |
(Boolean)jLocalOnly,false,false,CIMPropertyList())); |
cop->getNameSpace(),*cop,assocClass,role, |
return (jint)(void*)inst; |
(Boolean)includeQualifiers,(Boolean)includeClassOrigin,pl); |
|
Array<CIMInstance> *enmInst=new Array<CIMInstance>(); |
|
for (int i=0,m=enm.size(); i<m; i++) { |
|
enmInst->append(CIMInstance(enm[i])); |
|
} |
|
return (jint)enmInst; |
} | } |
Catch(jEnv); | Catch(jEnv); |
return -1; |
return 0; |
} | } |
| |
| |
| |
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent |
|
(JNIEnv *jEnv, jobject jThs, jint jCh, jstring jName, jstring jNs, jint jInd) { |
|
|
|
CIMOMHandle *ch=(CIMOMHandle*)jCh; |
|
CIMInstance *ind=(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); |
|
|
|
JMPIProviderManager::indProvRecord *prec; |
|
OperationContext* context; |
|
|
|
if (JMPIProviderManager::provTab.lookup(name,prec)) { |
|
if (prec->enabled) { |
|
context=prec->ctx; |
|
try { |
|
prec->handler->deliver(*context, *ind); |
|
} |
|
Catch(jEnv); |
|
} |
|
} |
|
else { |
|
if (JMPIjvm::trace) |
|
cerr<<"_deliverEvent() "<<name<<" not found"<<endl; |
|
} |
|
} |
|
|
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
// - CIMClass | // - CIMClass |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1newInstance | 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=(CIMClass*)jCls; |
// Array<Sint8> ar; |
|
// cls->toXml(ar); |
|
// cout<<"--- class: "<<ar.getData()<<endl; |
|
|
|
try { | try { |
CIMInstance *ci=new CIMInstance(cls->getClassName()); | CIMInstance *ci=new CIMInstance(cls->getClassName()); |
for (int i=0,m=cls->getQualifierCount(); i<m; i++) |
for (int i=0,m=cls->getQualifierCount(); i<m; i++) { |
|
try { |
ci->addQualifier(cls->getQualifier(i).clone()); | ci->addQualifier(cls->getQualifier(i).clone()); |
|
} |
|
catch (Exception e) {} |
|
} |
for (int i=0,m=cls->getPropertyCount(); i<m; i++) { | for (int i=0,m=cls->getPropertyCount(); i<m; i++) { |
CIMProperty cp= cls->getProperty(i); | CIMProperty cp= cls->getProperty(i); |
ci->addProperty(cp.clone()); | ci->addProperty(cp.clone()); |
// CIMProperty(cp.getName(), cp.getValue(), cp.getArraySize(), |
for (int j=0, s=cp.getQualifierCount(); j<s; j++) { |
// cp.getReferenceClassName(), cp.getClassOrigin())); |
try { |
for (int j=0, s=cp.getQualifierCount(); j<s; j++) |
|
ci->getProperty(i).addQualifier(cp.getQualifier(j)); | ci->getProperty(i).addQualifier(cp.getQualifier(j)); |
} | } |
|
catch (Exception e) {} |
|
} |
|
} |
return (jint)ci; | return (jint)ci; |
} | } |
Catch(jEnv); | Catch(jEnv); |
|
|
return jVec; | return jVec; |
} | } |
| |
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1addProperty |
|
(JNIEnv *jEnv, jobject jThs, jint jCls, jint jP) { |
|
CIMClass *cls=(CIMClass*)jCls; |
|
CIMProperty *p=(CIMProperty*)jP; |
|
cls->addProperty(*p); |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1setProperties |
|
(JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) { |
|
CIMClass *cls=(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++) { |
|
jobject o=jEnv->CallObjectMethod(jVec,instanceMethodIDs[16],(i)); |
|
CIMProperty *cp=(CIMProperty*)jEnv->CallIntMethod(o,instanceMethodIDs[29]); |
|
cls->addProperty(*cp); |
|
} |
|
} |
|
|
|
|
|
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifiers |
|
(JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec) { |
|
CIMClass *cls=(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); |
|
jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],qual); |
|
} |
|
return jVec; |
|
} |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1new | 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); | const char *str=jEnv->GetStringUTFChars(jN,NULL); |
|
|
delete cls; | delete cls; |
} | } |
| |
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1filterProperties |
|
(JNIEnv *jEnv, jobject jThs, jint jInst, jobjectArray jPl, jboolean iq, jboolean ic, jboolean lo) { |
|
CIMClass *cc=(CIMClass *)jInst; |
|
CIMClass* cf; |
|
CIMName clsn=cc->getClassName(); |
|
|
|
if (lo) { |
|
cf=new CIMClass(cc->clone()); |
|
CIMName clsn=cc->getClassName(); |
|
for (int i=cf->getPropertyCount()-1; i>=0; i--) |
|
if (cf->getProperty(i).getClassOrigin()==clsn) cf->removeProperty(i); |
|
return (jint)cf; |
|
} |
|
|
|
else if (jPl) { |
|
CIMPropertyList pl=getList(jEnv,jPl); |
|
Array<CIMName> n=pl.getPropertyNameArray(); |
|
cf=new CIMClass(clsn, cc->getSuperClassName()); |
|
for (int i=0,s=n.size(); i<s; i++) { |
|
Uint32 pos=cc->findProperty(n[i]); |
|
if (pos!=PEG_NOT_FOUND) { |
|
if (iq) { |
|
CIMProperty cp=cc->getProperty(pos).clone(); |
|
if (!ic) cp.setClassOrigin(CIMName()); |
|
cf->addProperty(cp); |
|
} |
|
else { |
|
CIMProperty cp=cc->getProperty(pos); |
|
CIMName co; |
|
if (ic) co=cp.getClassOrigin(); |
|
CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(), |
|
cp.getReferenceClassName(),co,cp.getPropagated()); |
|
cf->addProperty(np); |
|
} |
|
} |
|
} |
|
if (iq) for (Uint32 i=0,s=cc->getQualifierCount(); i<s; i++) |
|
cf->addQualifier(cc->getQualifier(i)); |
|
} |
|
|
|
else if (iq) { |
|
cf=new CIMClass(cc->clone()); |
|
if (ic) return (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(), |
|
cp.getReferenceClassName(),co,cp.getPropagated()); |
|
cf->addProperty(np); |
|
} |
|
} |
|
|
|
return (jint)cf; |
|
} |
|
|
| |
| |
// ------------------------------------- | // ------------------------------------- |
|
|
CIMValue *cv=(CIMValue*)jV; | CIMValue *cv=(CIMValue*)jV; |
const char *str=jEnv->GetStringUTFChars(jN,NULL); | const char *str=jEnv->GetStringUTFChars(jN,NULL); |
Uint32 pos=ci->findProperty(CIMName(str)); | Uint32 pos=ci->findProperty(CIMName(str)); |
|
try { |
if (pos!=PEG_NOT_FOUND) { | if (pos!=PEG_NOT_FOUND) { |
CIMProperty cp=ci->getProperty(pos); | CIMProperty cp=ci->getProperty(pos); |
if (cp.getType()==cv->getType()) | if (cp.getType()==cv->getType()) |
cp.setValue(*cv); | cp.setValue(*cv); |
else { | else { |
|
if (JMPIjvm::trace) |
|
cerr<<"!!! CIMInstance.setProperty - Wrong type of CIMValue (instance name:" |
|
<<ci->getClassName().getString()<<", property name: "<<str<<")"; |
|
if (JMPIjvm::trace) |
|
cerr<<"!!! CIMInstance.setProperty : "<<cp.getType()<<" <> "<<cv->getType()<<endl; |
throw CIMException(CIM_ERR_FAILED, String("Type mismatch")); | throw CIMException(CIM_ERR_FAILED, String("Type mismatch")); |
cerr<<"!!! CIMInstance.setProperty - Wrong type of CIMValue (instance name:"<<ci->getClassName().getString()<<", property name: "<<str<<")"; |
|
} | } |
|
ci->removeProperty(pos); |
|
ci->addProperty(cp); |
} | } |
else { | else { |
CIMProperty *cp=new CIMProperty(CIMName(str),*cv); | CIMProperty *cp=new CIMProperty(CIMName(str),*cv); |
ci->addProperty(*cp); | ci->addProperty(*cp); |
//throw CIMException(CIM_ERR_FAILED, String(str).append(String(" - Property not found"))); |
|
} | } |
|
} |
|
Catch(jEnv); |
| |
jEnv->ReleaseStringUTFChars(jN,str); | jEnv->ReleaseStringUTFChars(jN,str); |
} | } |
| |
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperties |
|
(JNIEnv *jEnv, jobject jThs, jint jInst, jobject jV) { |
|
throw CIMException(CIM_ERR_NOT_SUPPORTED, String("Not yet supported")); |
|
} |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperty | 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=(CIMInstance*)jInst; |
|
|
delete ci; | delete ci; |
} | } |
| |
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1filterProperties |
|
(JNIEnv *jEnv, jobject jThs, jint jInst, jobjectArray jPl, jboolean iq, jboolean ic, jboolean lo) { |
|
CIMInstance *ci=(CIMInstance *)jInst; |
|
CIMInstance* cf; |
|
CIMName clsn=ci->getClassName(); |
|
|
|
if (lo) { |
|
cf=new CIMInstance(ci->clone()); |
|
CIMName clsn=ci->getClassName(); |
|
for (int i=cf->getPropertyCount()-1; i>=0; i--) |
|
if (cf->getProperty(i).getClassOrigin()==clsn) cf->removeProperty(i); |
|
return (jint)cf; |
|
} |
|
|
|
else if (jPl) { |
|
CIMPropertyList pl=getList(jEnv,jPl); |
|
Array<CIMName> n=pl.getPropertyNameArray(); |
|
cf=new CIMInstance(clsn); |
|
for (int i=0,s=n.size(); i<s; i++) { |
|
Uint32 pos=ci->findProperty(n[i]); |
|
if (pos!=PEG_NOT_FOUND) { |
|
if (iq) { |
|
CIMProperty cp=ci->getProperty(pos).clone(); |
|
if (!ic) cp.setClassOrigin(CIMName()); |
|
cf->addProperty(cp); |
|
} |
|
else { |
|
CIMProperty cp=ci->getProperty(pos); |
|
CIMName co; |
|
if (ic) co=cp.getClassOrigin(); |
|
CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(), |
|
cp.getReferenceClassName(),co,cp.getPropagated()); |
|
cf->addProperty(np); |
|
} |
|
} |
|
} |
|
cf->setPath(ci->getPath()); |
|
} |
|
|
|
else if (iq) { |
|
cf=new CIMInstance(ci->clone()); |
|
if (ic) return (jint)cf; |
|
for (int i=cf->getPropertyCount()-1; i>=0; i--) { |
|
CIMProperty cp=cf->getProperty(i); |
|
cp.setClassOrigin(CIMName()); |
|
cf->removeProperty(i); |
|
cf->addProperty(cp); |
|
} |
|
} |
|
|
|
else { |
|
cf=new CIMInstance(clsn); |
|
for (int i=ci->getPropertyCount()-1; i>=0; i--) { |
|
CIMProperty cp=ci->getProperty(i); |
|
CIMName co; |
|
if (ic) co=cp.getClassOrigin(); |
|
CIMProperty np(cp.getName(),cp.getValue(),cp.getArraySize(), |
|
cp.getReferenceClassName(),co,cp.getPropagated()); |
|
cf->addProperty(np); |
|
} |
|
cf->setPath(ci->getPath()); |
|
} |
|
|
|
return (jint)cf; |
|
} |
| |
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCnNs | 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(); | CIMObjectPath *cop=construct(); |
|
const char *str1=NULL; |
|
const char *str2=NULL; |
| |
const char *str1=jEnv->GetStringUTFChars(jCn,NULL); |
|
const char *str2=jEnv->GetStringUTFChars(jNs,NULL); |
|
try { | try { |
|
if (jCn) str1=jEnv->GetStringUTFChars(jCn,NULL); |
|
if (jNs) str2=jEnv->GetStringUTFChars(jNs,NULL); |
if (str1) cop->setClassName(str1); | if (str1) cop->setClassName(str1); |
if (str2) cop->setNameSpace(str2); | if (str2) cop->setNameSpace(str2); |
} | } |
catch (Exception e) { |
Catch(jEnv); |
jobject ev=jEnv->NewObject(classRefs[13],instanceMethodIDs[33],(jint)1,jEnv->NewStringUTF(e.getMessage().getCString())); |
|
jEnv->Throw((jthrowable)ev); |
|
} |
|
| |
jEnv->ReleaseStringUTFChars(jCn,str1); |
if (str1) jEnv->ReleaseStringUTFChars(jCn,str1); |
jEnv->ReleaseStringUTFChars(jNs,str2); |
if (str2) jEnv->ReleaseStringUTFChars(jNs,str2); |
return (jint)(void*)cop; | return (jint)(void*)cop; |
} | } |
| |
|
|
(JNIEnv *jEnv, jobject jThs, jint jOp, jobject jVec) { | (JNIEnv *jEnv, jobject jThs, jint jOp, jobject jVec) { |
CIMObjectPath *cop=(CIMObjectPath*)jOp; | CIMObjectPath *cop=(CIMObjectPath*)jOp; |
Array<CIMKeyBinding> akb; | Array<CIMKeyBinding> akb; |
for (Uint32 i=0,s=jEnv->CallIntMethod(jVec,JMPIjvm::jv.VectorSize); i<s; i++) { |
for (Uint32 i=0,s=jEnv->CallIntMethod(jVec,instanceMethodIDs[28]); i<s; i++) { |
jobject o=jEnv->CallObjectMethod(jVec,JMPIjvm::jv.VectorElementAt,(i)); |
jobject o=jEnv->CallObjectMethod(jVec,instanceMethodIDs[16],(i)); |
CIMProperty *cp=(CIMProperty*)jEnv->CallIntMethod(o,JMPIjvm::jv.PropertyCInst); |
CIMProperty *cp=(CIMProperty*)jEnv->CallIntMethod(o,instanceMethodIDs[29]); |
akb.append(CIMKeyBinding(cp->getName(),cp->getValue())); | akb.append(CIMKeyBinding(cp->getName(),cp->getValue())); |
} | } |
cop->setKeyBindings(akb); | cop->setKeyBindings(akb); |
|
|
return str; | return str; |
} | } |
| |
|
CIMType toPtype(int jType) { |
|
if (jType>13) return (CIMType)14; |
|
return (CIMType)(jTypeToPType[jType]); |
|
} |
|
|
|
|
|
// ------------------------------------- |
|
// --- |
|
// - CIMArgument |
|
// --- |
|
// ------------------------------------- |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1getValue |
|
(JNIEnv *jEnv, jobject jThs, jint jP) { |
|
CIMParamValue *cp=(CIMParamValue*)jP; |
|
CIMValue *cv=new CIMValue(cp->getValue()); |
|
return (jint)cv; |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1new |
|
(JNIEnv *jEnv, jobject jThs) { |
|
CIMParamValue *p=new CIMParamValue(String::EMPTY,CIMValue()); |
|
return (jint)p; |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1newS |
|
(JNIEnv *jEnv, jobject jThs, jstring jN) { |
|
const char *str=jEnv->GetStringUTFChars(jN,NULL); |
|
CIMParamValue *p=new CIMParamValue(str,CIMValue()); |
|
jEnv->ReleaseStringUTFChars(jN,str); |
|
return (jint)p; |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1newSV |
|
(JNIEnv *jEnv, jobject jThs, jstring jN, jint jV) { |
|
const char *str=jEnv->GetStringUTFChars(jN,NULL); |
|
CIMValue *cv=(CIMValue*)jV; |
|
CIMParamValue *p=new CIMParamValue(str,cv); |
|
jEnv->ReleaseStringUTFChars(jN,str); |
|
return (jint)p; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setValue |
|
(JNIEnv *jEnv, jobject jThs, jint jP,jint jV) { |
|
CIMParamValue *cp=(CIMParamValue*)jP; |
|
CIMValue *cv=(CIMValue*)jV; |
|
cp->setValue(*cv); |
|
} |
|
|
|
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMArgument__1getName |
|
(JNIEnv *jEnv, jobject jThs, jint jP) { |
|
CIMParamValue *cp=(CIMParamValue*)jP; |
|
const String &n=cp->getParameterName(); |
|
jstring str=jEnv->NewStringUTF(n.getCString()); |
|
return str; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setName |
|
(JNIEnv *jEnv, jobject jThs, jint jP, jstring jN) { |
|
CIMParamValue *cp=(CIMParamValue*)jP; |
|
const char *str=jEnv->GetStringUTFChars(jN,NULL); |
|
String n(str); |
|
cp->setParameterName(n); |
|
jEnv->ReleaseStringUTFChars(jN,str); |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1getType |
|
(JNIEnv *jEnv, jobject jThs, jint jP) { |
|
CIMParamValue *cp=(CIMParamValue*)jP; |
|
const CIMValue cv=cp->getValue(); |
|
String ref; |
|
_dataType *type=new _dataType(pTypeToJType[cv.getType()], |
|
cv.getArraySize(), |
|
false, |
|
false, |
|
cv.isArray(), |
|
ref, |
|
true); |
|
return (jint)type; |
|
} |
|
|
|
|
| |
| |
// ------------------------------------- | // ------------------------------------- |
|
|
return (jint)cv; | return (jint)cv; |
} | } |
| |
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1new |
|
(JNIEnv *jEnv, jobject jThs, jstring jN, jint jV) { |
|
CIMProperty *p=new CIMProperty(CIMName(),CIMValue()); |
|
return (jint)p; |
|
} |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1property | 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 { | try { |
|
|
refarr.append(ref); | refarr.append(ref); |
} | } |
break; | break; |
|
case CIMTYPE_OBJECT: { |
|
CIMObject obj; |
|
cvin->get(obj); |
|
Array<CIMObject> objarr; |
|
cv.get(objarr); |
|
objarr.append(obj); |
|
} |
|
break; |
default: | default: |
throwCIMException(jEnv,"+++ unsupported type "); | throwCIMException(jEnv,"+++ unsupported type "); |
} | } |
} | } |
| |
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addQualifier |
|
(JNIEnv *jEnv, jobject jThs, jint jP, jint jQ) { |
|
CIMProperty *cp=(CIMProperty*)jP; |
|
CIMQualifier *cq=(CIMQualifier*)jQ; |
|
cp->addQualifier(*cq); |
|
} |
|
|
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getName | 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=(CIMProperty*)jP; |
|
|
return str; | return str; |
} | } |
| |
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setName |
|
(JNIEnv *jEnv, jobject jThs, jint jP, jstring jN) { |
|
CIMProperty *cp=(CIMProperty*)jP; |
|
const char *str=jEnv->GetStringUTFChars(jN,NULL); |
|
cp->setName(CIMName(str)); |
|
jEnv->ReleaseStringUTFChars(jN,str); |
|
} |
|
|
JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isReference | 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=(CIMProperty*)jP; |
|
|
return (jint)type; | return (jint)type; |
} | } |
| |
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1setType |
|
(JNIEnv *jEnv, jobject jThs, jint jP, jint jDt) { |
|
CIMProperty *cp=(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; |
|
} |
|
|
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMProperty__1getIdentifier | 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=(CIMProperty*)jP; |
|
|
| |
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
|
// - CIMQualifierType |
|
// --- |
|
// ------------------------------------- |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1new |
|
(JNIEnv *jEnv, jobject jThs) { |
|
CIMQualifierDecl *qual = new CIMQualifierDecl(); |
|
return (jint)(void*)qual; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1finalize |
|
(JNIEnv *jEnv, jobject jThs, jint jQ) { |
|
CIMQualifierDecl *qt=(CIMQualifierDecl*)jQ; |
|
delete qt; |
|
} |
|
|
|
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1getName |
|
(JNIEnv *jEnv, jobject jThs, jint jQ) { |
|
CIMQualifierDecl *qt=(CIMQualifierDecl*)jQ; |
|
const String &n=qt->getName().getString(); |
|
jstring str=jEnv->NewStringUTF(n.getCString()); |
|
return str; |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setName |
|
(JNIEnv *jEnv, jobject jThs, jint jQ, jstring jN) { |
|
CIMQualifierDecl *nqt,*qt=(CIMQualifierDecl*)jQ; |
|
nqt=qt; |
|
const char *str=jEnv->GetStringUTFChars(jN,NULL); |
|
if (qt->isUninitialized()) |
|
nqt=new CIMQualifierDecl(CIMName(str),CIMValue(),CIMScope()); |
|
else qt->setName(CIMName(str)); |
|
jEnv->ReleaseStringUTFChars(jN,str); |
|
return (jint)nqt; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setValue |
|
(JNIEnv *jEnv, jobject jThs, jint jQ,jint jV) { |
|
CIMQualifierDecl *qt=(CIMQualifierDecl*)jQ; |
|
CIMValue *cv=(CIMValue*)jV; |
|
qt->setValue(*cv); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
// ------------------------------------- |
|
// --- |
// - CIMQualifier | // - CIMQualifier |
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1finalize |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifier__1new |
|
(JNIEnv *jEnv, jobject jThs, jstring jN) { |
|
const char *str=jEnv->GetStringUTFChars(jN,NULL); |
|
CIMQualifier *qual = new CIMQualifier(CIMName(str),CIMValue()); |
|
jEnv->ReleaseStringUTFChars(jN,str); |
|
return (jint)(void*)qual; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1finalize |
|
(JNIEnv *jEnv, jobject jThs, jint jQ) { |
|
CIMQualifier *cq=(CIMQualifier*)jQ; |
|
delete cq; |
|
} |
|
|
|
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getName |
|
(JNIEnv *jEnv, jobject jThs, jint jQ) { |
|
CIMQualifier *cq=(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=(CIMQualifier*)jQ; |
delete cq; |
CIMValue *cv=new CIMValue(cq->getValue()); |
|
return (jint)cv; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1setValue |
|
(JNIEnv *jEnv, jobject jThs, jint jQ,jint jV) { |
|
CIMQualifier *cq=(CIMQualifier*)jQ; |
|
CIMValue *cv=(CIMValue*)jV; |
|
cq->setValue(*cv); |
} | } |
| |
| |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType | 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; | CIMValue *cv=(CIMValue*)jP; |
return (jint)cv->getType(); |
return (jint)pTypeToJType[cv->getType()]; |
} | } |
| |
JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString | JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString |
|
|
} | } |
// throwCIMException(jEnv,"+++ DateTime not yet supported"); | // throwCIMException(jEnv,"+++ DateTime not yet supported"); |
break; | break; |
|
case CIMTYPE_OBJECT: |
|
throwCIMException(jEnv,"+++ Object not yet supported"); |
|
break; |
default: | default: |
throwCIMException(jEnv,"+++ unsupported type: "); | throwCIMException(jEnv,"+++ unsupported type: "); |
} | } |
|
|
case CIMTYPE_DATETIME: | case CIMTYPE_DATETIME: |
throwCIMException(jEnv,"+++ DateTime not yet supported"); | throwCIMException(jEnv,"+++ DateTime not yet supported"); |
break; | break; |
|
case CIMTYPE_OBJECT: |
|
throwCIMException(jEnv,"+++ Object not yet supported"); |
|
break; |
default: | default: |
throwCIMException(jEnv,"+++ unsupported type: "); | throwCIMException(jEnv,"+++ unsupported type: "); |
} | } |
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMValue__1finalize | 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; | CIMValue *cv=(CIMValue*)jV; |
delete cv; |
if (cv) delete cv; |
} | } |
| |
| |
|
|
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1getClass |
|
(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) { |
|
Array<CIMClass> *enm=(Array<CIMClass>*)jEnum; |
|
return (jint) new CIMClass((*enm)[pos]); |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1size |
|
(JNIEnv *jEnv, jobject jThs, jint jEnum) { |
|
Array<CIMClass> *enm=(Array<CIMClass>*)jEnum; |
|
return enm->size(); |
|
} |
|
|
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1getInstance | 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) { |
|
|
return enm->size(); | return enm->size(); |
} | } |
| |
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1getQualifierType |
|
(JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos) { |
|
Array<CIMQualifierDecl> *enm=(Array<CIMQualifierDecl>*)jEnum; |
|
return (jint) new CIMQualifierDecl((*enm)[pos]); |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1size |
|
(JNIEnv *jEnv, jobject jThs, jint jEnum) { |
|
Array<CIMQualifierDecl> *enm=(Array<CIMQualifierDecl>*)jEnum; |
|
return enm->size(); |
|
} |
|
|
|
|
|
|
// ------------------------------------- | // ------------------------------------- |
// --- | // --- |
// - CIMClient | // - CIMClient |
// --- | // --- |
// ------------------------------------- | // ------------------------------------- |
| |
|
void checkNs(CIMObjectPath *cop, jint jNs) { |
|
if (cop->getNameSpace().isNull()) { |
|
_nameSpace *ns=(_nameSpace*)jNs; |
|
cop->setNameSpace(CIMNamespaceName(ns->nameSpace())); |
|
} |
|
} |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1newNaUnPw | 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=(_nameSpace*)jNs; |
|
|
const char *pw=jEnv->GetStringUTFChars(jPw,NULL); | const char *pw=jEnv->GetStringUTFChars(jPw,NULL); |
| |
try { | try { |
|
JMPIjvm::cacheIDs(jEnv); |
CIMClient *cc=new CIMClient(); | CIMClient *cc=new CIMClient(); |
cc->connect(cNs->hostName(),cNs->port(),un,pw); | cc->connect(cNs->hostName(),cNs->port(),un,pw); |
jEnv->ReleaseStringUTFChars(jUn,un); | jEnv->ReleaseStringUTFChars(jUn,un); |
jEnv->ReleaseStringUTFChars(jPw,pw); | jEnv->ReleaseStringUTFChars(jPw,pw); |
cout<<"### connect ok "<<(jint)(void*)cc<<endl; |
|
return (jint)(void*)cc; | return (jint)(void*)cc; |
} | } |
catch (CIMException e) { |
Catch(jEnv); |
jEnv->ReleaseStringUTFChars(jUn,un); |
|
jEnv->ReleaseStringUTFChars(jPw,pw); |
|
throwCimException(jEnv,e); |
|
} |
|
catch (...) { |
|
jEnv->ReleaseStringUTFChars(jUn,un); |
|
jEnv->ReleaseStringUTFChars(jPw,pw); |
|
throwFailedException(jEnv); |
|
} |
|
return 0; | return 0; |
} | } |
| |
|
|
try { | try { |
cCc->disconnect(); | cCc->disconnect(); |
} | } |
catch (CIMException e) { |
Catch(jEnv); |
throwCimException(jEnv,e); |
|
} |
|
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getClass | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getClass |
(JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jboolean lo) { |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean lo, |
|
jboolean iq, jboolean ic, jobjectArray jPl) { |
CIMClient *cCc=(CIMClient*)jCc; | CIMClient *cCc=(CIMClient*)jCc; |
CIMObjectPath *cop=(CIMObjectPath*)jCop; | CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMPropertyList pl=getList(jEnv,jPl); |
try { | try { |
CIMClass cls=cCc->getClass(cop->getNameSpace(),cop->getClassName(),(Boolean)lo); |
checkNs(cop,jNs); |
|
CIMClass cls=cCc->getClass(cop->getNameSpace(),cop->getClassName(),(Boolean)lo, |
|
(Boolean)iq,(Boolean)ic,pl); |
return (jint) new CIMClass(cls); | return (jint) new CIMClass(cls); |
} | } |
catch (CIMException e) { |
Catch(jEnv); |
throwCimException(jEnv,e); |
return 0; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteClass |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop) { |
|
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(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) { |
|
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMClass *cl=(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) { |
|
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMClass *cl=(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) { |
|
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(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); |
|
} |
|
Catch(jEnv); |
|
return 0; |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClassNames |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep) { |
|
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMNamespaceName ns=cop->getNameSpace(); |
|
try { |
|
checkNs(cop,jNs); |
|
Array<CIMName> enm=cCc->enumerateClassNames(ns,cop->getClassName(),(Boolean)deep); |
|
Array<CIMObjectPath> *enmop=new Array<CIMObjectPath>(); |
|
for (int i=0,m=enm.size(); i<m; i++) { |
|
enmop->append(CIMObjectPath(String::EMPTY,ns,enm[i])); |
|
} |
|
return (jint)enmop; |
} | } |
|
Catch(jEnv); |
|
return 0; |
|
} |
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateQualifiers |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, int jCop) { |
|
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
try { |
|
checkNs(cop,jNs); |
|
Array<CIMQualifierDecl> enm=cCc->enumerateQualifiers( |
|
cop->getNameSpace()); |
|
return (jint) new Array<CIMQualifierDecl>(enm); |
|
} |
|
Catch(jEnv); |
return 0; | return 0; |
} | } |
| |
|
|
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getInstance | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getInstance |
(JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jboolean lo) { |
(JNIEnv *jEnv, jobject jThs, jint jCc, int jNs, int jCop, jboolean lo, |
|
jboolean iq, jboolean ic, jobjectArray jPl) { |
CIMClient *cCc=(CIMClient*)jCc; | CIMClient *cCc=(CIMClient*)jCc; |
CIMObjectPath *cop=(CIMObjectPath*)jCop; | CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMPropertyList pl=getList(jEnv,jPl); |
|
|
try { | try { |
CIMInstance inst=cCc->getInstance(cop->getNameSpace(),*cop,(Boolean)lo); |
checkNs(cop,jNs); |
|
CIMInstance inst=cCc->getInstance(cop->getNameSpace(),*cop,(Boolean)lo, |
|
(Boolean)iq,(Boolean)ic,pl); |
return (jint) new CIMInstance(inst); | return (jint) new CIMInstance(inst); |
} | } |
catch (CIMException e) { |
Catch(jEnv); |
throwCimException(jEnv,e); |
return 0; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteInstance |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop) { |
|
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(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) { |
|
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMInstance *ci=(CIMInstance*)jCi; |
|
try { |
|
checkNs(cop,jNs); |
|
ci->setPath(*cop); |
|
CIMObjectPath obj=cCc->createInstance(cop->getNameSpace(),*ci); |
|
return (jint) new CIMObjectPath(obj); |
} | } |
|
Catch(jEnv); |
return 0; | return 0; |
} | } |
| |
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1modifyInstance |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jCi, |
|
jboolean iq, jobjectArray jPl) { |
|
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMInstance *ci=(CIMInstance*)jCi; |
|
CIMPropertyList pl=getList(jEnv,jPl); |
|
try { |
|
checkNs(cop,jNs); |
|
ci->setPath(*cop); |
|
cCc->modifyInstance(cop->getNameSpace(),*ci,(Boolean)iq,pl); |
|
} |
|
Catch(jEnv); |
|
return ; |
|
} |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstances | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstances |
(JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jboolean deep, jboolean lo) { |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep, jboolean lo, |
|
jboolean iq, jboolean ic, jobjectArray jPl) { |
CIMClient *cCc=(CIMClient*)jCc; | CIMClient *cCc=(CIMClient*)jCc; |
CIMObjectPath *cop=(CIMObjectPath*)jCop; | CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMPropertyList pl=getList(jEnv,jPl); |
try { | try { |
|
checkNs(cop,jNs); |
|
CIMPropertyList props; |
Array<CIMInstance> enm=cCc->enumerateInstances( | Array<CIMInstance> enm=cCc->enumerateInstances( |
cop->getNameSpace(),cop->getClassName(),(Boolean)deep,(Boolean)lo); |
cop->getNameSpace(),cop->getClassName(),(Boolean)deep,(Boolean)lo,(Boolean)iq,(Boolean)ic,pl); |
return (jint) new Array<CIMInstance>(enm); | return (jint) new Array<CIMInstance>(enm); |
} | } |
catch (CIMException e) { |
Catch(jEnv); |
throwCimException(jEnv,e); |
|
} |
|
return 0; | return 0; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstanceNames | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstanceNames |
(JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jboolean deep) { |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep) { |
CIMClient *cCc=(CIMClient*)jCc; | CIMClient *cCc=(CIMClient*)jCc; |
CIMObjectPath *cop=(CIMObjectPath*)jCop; | CIMObjectPath *cop=(CIMObjectPath*)jCop; |
try { | try { |
|
checkNs(cop,jNs); |
Array<CIMObjectPath> enm=cCc->enumerateInstanceNames( | Array<CIMObjectPath> enm=cCc->enumerateInstanceNames( |
cop->getNameSpace(),cop->getClassName()); //,(Boolean)deep); | cop->getNameSpace(),cop->getClassName()); //,(Boolean)deep); |
return (jint) new Array<CIMObjectPath>(enm); | return (jint) new Array<CIMObjectPath>(enm); |
} | } |
catch (CIMException e) { |
Catch(jEnv); |
throwCimException(jEnv,e); |
|
} |
|
return 0; | return 0; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1createInstance |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, int jCi) { |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getQualifier |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop) { |
CIMClient *cCc=(CIMClient*)jCc; | CIMClient *cCc=(CIMClient*)jCc; |
CIMObjectPath *cop=(CIMObjectPath*)jCop; | CIMObjectPath *cop=(CIMObjectPath*)jCop; |
CIMInstance *ci=(CIMInstance*)jCi; |
|
|
|
try { | try { |
CIMObjectPath obj=cCc->createInstance(cop->getNameSpace(),*ci); |
checkNs(cop,jNs); |
return (jint) new CIMObjectPath(obj); |
CIMQualifierDecl *val=new CIMQualifierDecl(cCc->getQualifier(cop->getNameSpace(),cop->getClassName())); |
} |
return (jint)val; |
catch (CIMException e) { |
|
throwCimException(jEnv,e); |
|
} | } |
|
Catch(jEnv); |
return 0; | return 0; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setInstance |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteQualifier |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jint jCi) { |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop) { |
CIMClient *cCc=(CIMClient*)jCc; | CIMClient *cCc=(CIMClient*)jCc; |
CIMObjectPath *cop=(CIMObjectPath*)jCop; | CIMObjectPath *cop=(CIMObjectPath*)jCop; |
CIMInstance *ci=(CIMInstance*)jCi; |
|
|
|
try { | try { |
cCc->modifyInstance(cop->getNameSpace(),*ci); |
checkNs(cop,jNs); |
|
cCc->deleteQualifier(cop->getNameSpace(),cop->getClassName()); |
} | } |
catch (CIMException e) { |
Catch(jEnv); |
throwCimException(jEnv,e); |
return; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setQualifier |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jQ) { |
|
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMQualifierDecl *qt=(CIMQualifierDecl*)jQ; |
|
try { |
|
checkNs(cop,jNs); |
|
cCc->setQualifier(cop->getNameSpace(),*qt); |
} | } |
|
Catch(jEnv); |
return ; | return ; |
} | } |
| |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty |
(JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jstring jPn) { |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn) { |
throwNotSupportedException(jEnv); |
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
const char *str=jEnv->GetStringUTFChars(jPn,NULL); |
|
CIMName pName(str); |
|
jEnv->ReleaseStringUTFChars(jPn,str); |
|
try { |
|
checkNs(cop,jNs); |
|
CIMValue *val=new CIMValue(cCc->getProperty(cop->getNameSpace(),*cop,pName)); |
|
return (jint)val; |
|
} |
|
Catch(jEnv); |
return 0; | return 0; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty | JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jstring jPn, jint jV) { |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn, jint jV) { |
throwNotSupportedException(jEnv); |
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMValue *val=(CIMValue*)jCop; |
|
const char *str=jEnv->GetStringUTFChars(jPn,NULL); |
|
CIMName pName(str); |
|
jEnv->ReleaseStringUTFChars(jPn,str); |
|
try { |
|
checkNs(cop,jNs); |
|
cCc->setProperty(cop->getNameSpace(),*cop,pName,*val); |
|
} |
|
Catch(jEnv); |
return; | return; |
} | } |
| |
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteInstance |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop) { |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn, jobject jIn, jobject jOut) { |
throwNotSupportedException(jEnv); |
CIMClient *cCc=(CIMClient*)jCc; |
return; |
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
const char *str=jEnv->GetStringUTFChars(jMn,NULL); |
|
CIMName method(str); |
|
jEnv->ReleaseStringUTFChars(jMn,str); |
|
|
|
Array<CIMParamValue> in; |
|
Array<CIMParamValue> out; |
|
|
|
for (int i=0,m=jEnv->CallIntMethod(jIn,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])); |
|
JMPIjvm::checkException(jEnv); |
|
in.append(CIMParamValue(p->getName().getString(),p->getValue())); |
|
} |
|
try { |
|
checkNs(cop,jNs); |
|
CIMValue *val=new CIMValue(cCc->invokeMethod(cop->getNameSpace(),*cop,method,in,out)); |
|
|
|
for (int i=0,m=out.size(); i<m; i++) { |
|
const CIMParamValue & parm=out[i]; |
|
const CIMValue v=parm.getValue(); |
|
CIMProperty *p=new CIMProperty(parm.getParameterName(),v,v.getArraySize()); |
|
jobject prop=jEnv->NewObject(classRefs[15],instanceMethodIDs[14],(jint)p); |
|
jEnv->CallVoidMethod(jOut,instanceMethodIDs[15],prop); |
|
} |
|
return (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) { |
|
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
const char *str=jEnv->GetStringUTFChars(jMn,NULL); |
|
CIMName method(str); |
|
jEnv->ReleaseStringUTFChars(jMn,str); |
|
|
|
Array<CIMParamValue> in; |
|
Array<CIMParamValue> out; |
|
|
|
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])); |
|
JMPIjvm::checkException(jEnv); |
|
in.append(*p); |
|
} |
|
try { |
|
checkNs(cop,jNs); |
|
CIMValue *val=new CIMValue(cCc->invokeMethod(cop->getNameSpace(),*cop,method,in,out)); |
|
|
|
for (int i=0,m=out.size(),o=jEnv->GetArrayLength(jOut); i<m && i<o; i++) { |
|
const CIMParamValue & parm=out[i]; |
|
jEnv->SetObjectArrayElement(jOut,i, |
|
jEnv->NewObject(classRefs[29],instanceMethodIDs[40],(jint)&parm)); |
|
} |
|
return (jint)val; |
|
} |
|
Catch(jEnv); |
|
return 0; |
} | } |
| |
|
|
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery |
(JNIEnv *jEnv, jobject jThs, jint jCc, int jCop, jstring jQuery, jstring jQl) { |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jQuery, jstring jQl) { |
throwNotSupportedException(jEnv); |
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
|
|
const char *str=jEnv->GetStringUTFChars(jQuery,NULL); |
|
String query(str); |
|
jEnv->ReleaseStringUTFChars(jQuery,str); |
|
str=jEnv->GetStringUTFChars(jQl,NULL); |
|
String ql(str); |
|
jEnv->ReleaseStringUTFChars(jQl,str); |
|
|
|
try { |
|
checkNs(cop,jNs); |
|
Array<CIMObject> enm=cCc->execQuery( |
|
cop->getNameSpace(),query,ql); |
|
Array<CIMInstance> *enmInst=new Array<CIMInstance>(); |
|
for (int i=0,m=enm.size(); i<m; i++) { |
|
enmInst->append(CIMInstance(enm[i])); |
|
} |
|
return (jint)enmInst; |
|
} |
|
Catch(jEnv); |
return 0; | return 0; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associatorNames | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associatorNames |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, |
jstring assocClass, jstring resultClass, jstring role, jstring resultRole) { |
jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole) { |
throwNotSupportedException(jEnv); |
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
|
|
const char *str=jEnv->GetStringUTFChars(jAssocClass,NULL); |
|
CIMName assocClass(str); |
|
jEnv->ReleaseStringUTFChars(jAssocClass,str); |
|
str=jEnv->GetStringUTFChars(jResultClass,NULL); |
|
CIMName resultClass(str); |
|
jEnv->ReleaseStringUTFChars(jResultClass,str); |
|
str=jEnv->GetStringUTFChars(jRole,NULL); |
|
String role(str); |
|
jEnv->ReleaseStringUTFChars(jRole,str); |
|
str=jEnv->GetStringUTFChars(jResultRole,NULL); |
|
String resultRole(str); |
|
jEnv->ReleaseStringUTFChars(jResultRole,str); |
|
|
|
try { |
|
checkNs(cop,jNs); |
|
Array<CIMObjectPath> enm=cCc->associatorNames( |
|
cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole); |
|
return (jint) new Array<CIMObjectPath>(enm); |
|
} |
|
Catch(jEnv); |
return 0; | return 0; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associators | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associators |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, |
jstring assocClass, jstring resultClass, jstring role, jstring resultRole, |
jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole, |
jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray propertyList) { |
jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl) { |
throwNotSupportedException(jEnv); |
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMPropertyList pl=getList(jEnv,jPl); |
|
|
|
const char *str=jEnv->GetStringUTFChars(jAssocClass,NULL); |
|
CIMName assocClass(str); |
|
jEnv->ReleaseStringUTFChars(jAssocClass,str); |
|
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<CIMObject> enm=cCc->associators( |
|
cop->getNameSpace(),*cop,assocClass,resultClass,role,resultRole, |
|
(Boolean)includeQualifiers,(Boolean)includeClassOrigin,pl); |
|
Array<CIMInstance> *enmInst=new Array<CIMInstance>(); |
|
for (int i=0,m=enm.size(); i<m; i++) { |
|
enmInst->append(CIMInstance(enm[i])); |
|
} |
|
return (jint)enmInst; |
|
} |
|
Catch(jEnv); |
return 0; | return 0; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1referenceNames | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1referenceNames |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, |
jstring assocClass, jstring resultClass) { |
jstring jAssocClass, jstring jRole) { |
throwNotSupportedException(jEnv); |
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
|
|
const char *str=jEnv->GetStringUTFChars(jAssocClass,NULL); |
|
CIMName assocClass(str); |
|
jEnv->ReleaseStringUTFChars(jAssocClass,str); |
|
str=jEnv->GetStringUTFChars(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); |
|
} |
|
Catch(jEnv); |
return 0; | return 0; |
} | } |
| |
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1references | JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1references |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, |
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, |
jstring assocClass, jstring resultClass, |
jstring jAssocClass, jstring jRole, |
jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray propertyList) { |
jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl) { |
throwNotSupportedException(jEnv); |
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
CIMPropertyList pl=getList(jEnv,jPl); |
|
|
|
const char *str=jEnv->GetStringUTFChars(jAssocClass,NULL); |
|
CIMName assocClass(str); |
|
jEnv->ReleaseStringUTFChars(jAssocClass,str); |
|
str=jEnv->GetStringUTFChars(jRole,NULL); |
|
String role(str); |
|
jEnv->ReleaseStringUTFChars(jRole,str); |
|
|
|
try { |
|
checkNs(cop,jNs); |
|
Array<CIMObject> enm=cCc->references( |
|
cop->getNameSpace(),*cop,assocClass,role, |
|
(Boolean)includeQualifiers,(Boolean)includeClassOrigin,pl); |
|
Array<CIMInstance> *enmInst=new Array<CIMInstance>(); |
|
for (int i=0,m=enm.size(); i<m; i++) { |
|
enmInst->append(CIMInstance(enm[i])); |
|
} |
|
return (jint)enmInst; |
|
} |
|
Catch(jEnv); |
|
return 0; |
|
} |
|
|
|
static int normalizeNs(String &ns, String &nsBase, String &lastNsComp) { |
|
Uint32 n=ns.size(); |
|
if (ns[n-1]=='/') { |
|
if (n>=2) ns=ns.subString(0,n-2); |
|
} |
|
|
|
lastNsComp=ns; |
|
nsBase="root"; |
|
|
|
n=ns.reverseFind('/'); |
|
if (n!=PEG_NOT_FOUND) { |
|
lastNsComp=ns.subString(n+1); |
|
nsBase=ns.subString(0,n); |
|
} |
return 0; | return 0; |
} | } |
| |
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createNameSpace |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jstring jNs) { |
|
CIMClient *cCc=(CIMClient*)jCc; |
|
|
|
const char* str=jEnv->GetStringUTFChars(jNs,NULL); |
|
String ns(str); |
|
jEnv->ReleaseStringUTFChars(jNs,str); |
|
|
|
String lastNsComp; |
|
String nsBase; |
|
|
|
normalizeNs(ns,nsBase,lastNsComp); |
|
|
|
CIMInstance newInstance(CIMName("__Namespace")); |
|
newInstance.addProperty(CIMProperty(CIMName ("name"),lastNsComp)); |
|
|
|
try { |
|
cCc->createInstance(CIMNamespaceName(nsBase),newInstance); |
|
} |
|
Catch(jEnv); |
|
return; |
|
} |
|
|
|
JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateNameSpaces |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jboolean deep, jobject jVec) { |
|
|
|
CIMClient *cCc=(CIMClient*)jCc; |
|
CIMObjectPath *cop=(CIMObjectPath*)jCop; |
|
String ns=cop->getNameSpace().getString(); |
|
try { |
|
Array<CIMObjectPath> enm=cCc->enumerateInstanceNames( |
|
cop->getNameSpace(),CIMName("__Namespace")); |
|
for (int i=0,s=enm.size(); i<s; i++) { |
|
CIMObjectPath &cop=enm[i]; |
|
const Array<CIMKeyBinding>& kb=cop.getKeyBindings(); |
|
const String &n=kb[0].getValue(); |
|
if (!deep && n.find('/')!=PEG_NOT_FOUND) continue; |
|
String x=ns+"/"+n; |
|
jstring str=jEnv->NewStringUTF(x.getCString()); |
|
jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],str); |
|
} |
|
} |
|
Catch(jEnv); |
|
return jVec; |
|
} |
|
|
|
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteNameSpace |
|
(JNIEnv *jEnv, jobject jThs, jint jCc, jstring jNs) { |
|
CIMClient *cCc=(CIMClient*)jCc; |
|
|
|
const char* str=jEnv->GetStringUTFChars(jNs,NULL); |
|
String ns(str); |
|
jEnv->ReleaseStringUTFChars(jNs,str); |
|
String lastNsComp; |
|
String nsBase; |
|
|
|
normalizeNs(ns,nsBase,lastNsComp); |
|
|
|
CIMObjectPath cop(String::EMPTY,CIMNamespaceName(nsBase),CIMName("__Namespace")); |
|
Array<CIMKeyBinding> kb; |
|
kb.append(CIMKeyBinding(("Name"),CIMValue(lastNsComp))); |
|
cop.setKeyBindings(kb); |
|
|
|
try { |
|
cCc->deleteInstance(CIMNamespaceName(nsBase),cop); |
|
} |
|
Catch(jEnv); |
|
return; |
|
} |
|
|
} // extern "C" | } // extern "C" |
| |
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |