(file) Return to JMPIImpl.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / JMPI

Diff for /pegasus/src/Pegasus/ProviderManager2/JMPI/JMPIImpl.cpp between version 1.1 and 1.12

version 1.1, 2004/04/30 10:27:25 version 1.12, 2005/02/05 23:00:32
Line 1 
Line 1 
 //%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
Line 47 
Line 51 
 #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;
Line 87 
Line 93 
       "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
 }; };
  
  
Line 109 
Line 121 
 /*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" },
Line 127 
Line 139 
 /*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[]={
Line 162 
Line 185 
 } }
  
 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;
  
Line 187 
Line 212 
           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;
 } }
Line 195 
Line 222 
    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;
Line 204 
Line 247 
    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;
    }    }
  
Line 223 
Line 276 
  
    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;
Line 232 
Line 286 
    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()) {
Line 240 
Line 293 
       exit(1);       exit(1);
    }    }
  
 //   dlopen("libjmpiVM.so",RTLD_NOW);  
 //   std::cerr<<"--- JPIjvm::initJVM(): selfloading done\n";  
   
    return res;    return res;
 } }
  
Line 269 
Line 319 
    }    }
  
    /*    /*
    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());
Line 279 
Line 329 
       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;
Line 295 
Line 346 
    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;
Line 312 
Line 364 
  
    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;
Line 321 
Line 374 
    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;
Line 329 
Line 383 
  
 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;        else {
          throw CIMException((CIMStatusCode)code,m);           env->ExceptionDescribe();
            exit(13);
       }       }
    }    }
 } }
Line 445 
Line 506 
 } }
  
  
   
   
   // -------------------------------------
   // ---
   // -            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;
Line 506 
Line 790 
    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;    CIMOMHandle *ch=(CIMOMHandle*)jCh;
    CIMObjectPath *cop=(CIMObjectPath*)jCop;    CIMObjectPath *cop=(CIMObjectPath*)jCop;
    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<CIMObjectPath> enm=ch->associatorNames(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++){        return (jint) new Array<CIMObjectPath>(enm);
          CIMInstance *ci=new CIMInstance(inst[i]);  
          jobject jCi=jEnv->NewObject(classRefs[18],instanceMethodIDs[20],(jint)ci);  
          jEnv->CallVoidMethod(jVec,instanceMethodIDs[15],jCi);  
       }       }
      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;
      CIMObjectPath *cop=(CIMObjectPath*)jCop;
      CIMPropertyList pl=getList(jEnv,jPl);
      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<CIMObject> enm=ch->associators(ctx,
            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);    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
Line 565 
Line 1046 
 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);
Line 645 
Line 1128 
    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);
Line 705 
Line 1221 
    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;
   }
   
  
  
 // ------------------------------------- // -------------------------------------
Line 738 
Line 1320 
    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;
Line 834 
Line 1428 
    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;
   }
  
 // ------------------------------------- // -------------------------------------
 // --- // ---
Line 866 
Line 1525 
 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;
 } }
  
Line 1027 
Line 1685 
       (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);
Line 1132 
Line 1790 
    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;
   }
   
   
  
  
 // ------------------------------------- // -------------------------------------
Line 1147 
Line 1887 
    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 {
Line 1309 
Line 2055 
    }    }
 } }
  
   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;
Line 1317 
Line 2070 
    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;
Line 1345 
Line 2106 
    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;
Line 1363 
Line 2135 
  
 // ------------------------------------- // -------------------------------------
 // --- // ---
   // -     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);
 } }
  
  
Line 1647 
Line 2498 
 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
Line 1887 
Line 2738 
 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;
 } }
  
  
Line 2004 
Line 2855 
 // --- // ---
 // ------------------------------------- // -------------------------------------
  
   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) {
Line 2030 
Line 2893 
    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;
Line 2044 
Line 2928 
    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;
 } }
  
Line 2070 
Line 2945 
    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

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.12
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2