(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.30 and 1.35.2.2

version 1.30, 2005/06/25 00:04:29 version 1.35.2.2, 2006/05/17 20:57:39
Line 1 
Line 1 
 //%2005////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // 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.
Line 8 
Line 8 
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 // EMC Corporation; VERITAS Software Corporation; The Open Group. // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec 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 55 
Line 57 
 #include <Pegasus/Common/CIMInstance.h> #include <Pegasus/Common/CIMInstance.h>
 #include <Pegasus/Common/CIMObjectPath.h> #include <Pegasus/Common/CIMObjectPath.h>
 #include <Pegasus/Common/CIMProperty.h> #include <Pegasus/Common/CIMProperty.h>
 #include <Pegasus/Common/CIMType.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> #include <Pegasus/ProviderManager2/JMPI/JMPIProviderManager.h>
   #include <Pegasus/ProviderManager2/CMPI/CMPI_SelectExp.h>
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
Line 111 
Line 113 
 /*28*/ "org/pegasus/jmpi/CIMFlavor", /*28*/ "org/pegasus/jmpi/CIMFlavor",
 /*29*/ "org/pegasus/jmpi/CIMArgument", /*29*/ "org/pegasus/jmpi/CIMArgument",
 /*30*/ "org/pegasus/jmpi/CIMInstanceException", /*30*/ "org/pegasus/jmpi/CIMInstanceException",
   /*31*/ "org/pegasus/jmpi/CIMObject",
   /*32*/ "java/lang/Character",
   /*33*/ "org/pegasus/jmpi/OperationContext",
   /*34*/ "java/lang/Class",
 }; };
  
 const METHOD_STRUCT instanceMethodNames[]={ const METHOD_STRUCT instanceMethodNames[]={
Line 160 
Line 166 
 /*43 CIMExceptionNewStObOb   */ { /*CIMException  */13, "<init>",          "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)V" }, /*43 CIMExceptionNewStObOb   */ { /*CIMException  */13, "<init>",          "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)V" },
 /*44 CIMExceptionNewStObObOb */ { /*CIMException  */13, "<init>",          "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V" }, /*44 CIMExceptionNewStObObOb */ { /*CIMException  */13, "<init>",          "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V" },
 /*45 CIMValueNewI            */ { /*CIMValue      */19, "<init>",          "(I)V" }, /*45 CIMValueNewI            */ { /*CIMValue      */19, "<init>",          "(I)V" },
   /*46 CIMObjectNewIZ              */ { /*CIMObject        */31, "<init>",          "(IZ)V" },
   /*47 CharacterNewC               */ { /*Character        */32, "<init>",          "(C)V" },
   /*48 OperationContextNewI        */ { /*OperationContext */33, "<init>",          "(I)V" },
   /*49 OperationContextUnassociate */ { /*OperationContext */33, "unassociate",     "()V" },
   /*50 ClassGetInterfaces          */ { /*Class            */34, "getInterfaces",   "()[Ljava/lang/Class;" },
   /*51 ClassGetName                */ { /*Class            */34, "getName",         "()Ljava/lang/String;" },
 }; };
  
 const METHOD_STRUCT staticMethodNames[]={ const METHOD_STRUCT staticMethodNames[]={
Line 210 
Line 222 
  
 int JMPIjvm::cacheIDs(JNIEnv *env) int JMPIjvm::cacheIDs(JNIEnv *env)
 { {
    DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): enter"<<PEGASUS_STD(endl));  
   
    if (methodInitDone==1)    if (methodInitDone==1)
       return JNI_TRUE;       return JNI_TRUE;
    if (methodInitDone==-1)    if (methodInitDone==-1)
       return JNI_FALSE;       return JNI_FALSE;
  
      DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): enter"<<PEGASUS_STD(endl));
   
    methodInitDone=-1;    methodInitDone=-1;
  
    for (unsigned i=0; i<(sizeof(classNames)/sizeof(classNames[0])); i++) {    for (unsigned i=0; i<(sizeof(classNames)/sizeof(classNames[0])); i++) {
Line 280 
Line 292 
       JvmVector *jv;       JvmVector *jv;
  
       attachThread(&jv);       attachThread(&jv);
   
       jvm->DestroyJavaVM();       jvm->DestroyJavaVM();
  
       jvm = NULL;       jvm = NULL;
Line 291 
Line 304 
    return -1;    return -1;
 } }
  
   Mutex JMPIjvm::_initMutex;
   
 int JMPIjvm::initJVM() int JMPIjvm::initJVM()
 { {
      AutoMutex lock (_initMutex);
   
      if (jvm != NULL)
      {
         return 0;
      }
   
    JavaVMInitArgs vm_args;    JavaVMInitArgs vm_args;
    jint res;    jint res;
    char *envstring;    char *envstring;
Line 424 
Line 446 
    }    }
  
    if (res!=0) {    if (res!=0) {
         jv.initRc=1;
   
       DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): Can not create Java VM"<<PEGASUS_STD(endl));       DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): Can not create Java VM"<<PEGASUS_STD(endl));
  
       exit(1);        return -1;
    }    }
    jv.jvm=jvm;  
  
    cacheIDs(env);    cacheIDs(env);
  
    if (env->ExceptionOccurred()) {    if (env->ExceptionOccurred()) {
         jv.initRc=1;
   
       env->ExceptionDescribe();       env->ExceptionDescribe();
       exit(1);  
   #ifdef JAVA_DESTROY_VM_WORKS
   
         JvmVector *jv = NULL;
   
         attachThread (&jv);
   
         jvm->DestroyJavaVM ();
   
         jvm = NULL;
   #endif
   
         return -1;
    }    }
  
      jv.initRc=1;
      jv.jvm=jvm;
   
    return res;    return res;
 } }
  
 JNIEnv* JMPIjvm::attachThread(JvmVector **jvp) {  JNIEnv* JMPIjvm::attachThread(JvmVector **jvp)
    JNIEnv* env;  {
    if (jvm==NULL) initJVM();     JNIEnv* env = NULL;
   
      if (jvm == NULL)
      {
         initJVM ();
   
         if (jvm == NULL)
            return NULL;
      }
   
    jvm->AttachCurrentThread((void**)&env,NULL);    jvm->AttachCurrentThread((void**)&env,NULL);
   
    *jvp=&jv;    *jvp=&jv;
   
    return env;    return env;
 } }
  
Line 668 
Line 719 
  
  
  
   CIMPropertyList getList(JNIEnv *jEnv, jobjectArray l) {
      CIMPropertyList pl;
   
      if (l) {
         Array<CIMName> n;
   
         for (jsize i=0,s=jEnv->GetArrayLength(l); i<s; i++) {
            jstring     jObj = (jstring)jEnv->GetObjectArrayElement(l,i);
            const char *pn   = jEnv->GetStringUTFChars(jObj,NULL);
   
            n.append(pn);
   
            jEnv->ReleaseStringUTFChars(jObj,pn);
         }
   
         pl.set(n);
      }
   
      return pl;
   }
   
  
  
 extern "C" { extern "C" {
Line 738 
Line 810 
 // --- // ---
 // ------------------------------------- // -------------------------------------
  
 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)          jboolean iq, jboolean ic, jobjectArray jPl)
Line 838 
Line 889 
    OperationContext  ctx;    OperationContext  ctx;
  
    try {    try {
       Array<CIMName>        enm   = ch->enumerateClassNames(ctx,cop->getNameSpace(),cop->getClassName(),deep);        Array<CIMName>        enm   = ch->enumerateClassNames(ctx,cop->getNameSpace(),cop->getClassName(),(Boolean)deep);
       Array<CIMObjectPath> *enmop = new Array<CIMObjectPath>();       Array<CIMObjectPath> *enmop = new Array<CIMObjectPath>();
  
       for (int i=0,m=enm.size(); i<m; i++) {       for (int i=0,m=enm.size(); i<m; i++) {
Line 864 
Line 915 
       Array<CIMClass> en=ch->enumerateClasses(ctx,       Array<CIMClass> en=ch->enumerateClasses(ctx,
                                               cop->getNameSpace(),                                               cop->getNameSpace(),
                                               cop->getClassName(),                                               cop->getClassName(),
                                               deep,                                                (Boolean)deep,
                                               (Boolean)lo,                                               (Boolean)lo,
                                               iq,                                                (Boolean)iq,
                                               ic);                                                (Boolean)ic);
  
       return DEBUG_ConvertCToJava (Array<CIMClass>*, jint, new Array<CIMClass>(en));       return DEBUG_ConvertCToJava (Array<CIMClass>*, jint, new Array<CIMClass>(en));
    }    }
Line 991 
Line 1042 
       Array<CIMInstance> en=ch->enumerateInstances(ctx,       Array<CIMInstance> en=ch->enumerateInstances(ctx,
                                                    cop->getNameSpace(),                                                    cop->getNameSpace(),
                                                    cop->getClassName(),                                                    cop->getClassName(),
                                                    deep,                                                     (Boolean)deep,
                                                    lo,                                                     (Boolean)lo,
                                                    iq,                                                     (Boolean)iq,
                                                    ic,                                                     (Boolean)ic,
                                                    pl);                                                    pl);
       return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, new Array<CIMInstance>(en));       return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, new Array<CIMInstance>(en));
    }    }
Line 1217 
Line 1268 
    return 0;    return 0;
 } }
  
 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIM__1associators  JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associators
   (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop,   (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop,
    jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole,    jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole,
    jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)    jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)
Line 1363 
Line 1414 
  
    jEnv->ReleaseStringUTFChars(jNs,str);    jEnv->ReleaseStringUTFChars(jNs,str);
  
    CIMObjectPath ref(CIMObjectPath(ind->getPath()));     CIMObjectPath ref (ind->getPath ());
  
    ref.setNameSpace(ns);    ref.setNameSpace(ns);
      DDD(PEGASUS_STD(cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent() ref = "<<ref.toString ()<<PEGASUS_STD(endl));
      DDD(PEGASUS_STD(cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent() ind = "<<ind->getPath ().toString ()<<PEGASUS_STD(endl));
    ind->setPath(ref);    ind->setPath(ref);
      DDD(PEGASUS_STD(cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent() ind = "<<ind->getPath ().toString ()<<PEGASUS_STD(endl));
  
    JMPIProviderManager::indProvRecord *prec;     JMPIProviderManager::indProvRecord   *prec        = NULL;
    OperationContext* context;     String                                sPathString = ind->getPath ().toString ();
      OperationContext                     *context     = NULL;
      bool                                  fResult     = false;
  
    if (JMPIProviderManager::provTab.lookup(name,prec)) {     {
       if (prec->enabled) {        AutoMutex lock (JMPIProviderManager::mutexProvTab);
          context=prec->ctx;  
          try {        fResult = JMPIProviderManager::provTab.lookup (name, prec);
             prec->handler->deliver(*context, *ind);  
         DDD(PEGASUS_STD(cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent() fResult = "<<fResult<<", name = "<<name<<PEGASUS_STD(endl));
      }
   
      if (fResult)
      {
         if (prec->enabled)
         {
            try
            {
               prec->handler->deliver (*prec->ctx, *ind);
          }          }
          Catch(jEnv);          Catch(jEnv);
       }       }
    }    }
    else {     else
       DDD(PEGASUS_STD(cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent() "<<name<<" not found"<<PEGASUS_STD(endl));     {
         DDD(PEGASUS_STD(cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent() provider name \""<<name<<"\" not found"<<PEGASUS_STD(endl));
    }    }
 } }
  
Line 1858 
Line 1925 
  
    CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);    CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
  
   //@HACK
   //cout << "ci->getPropertyCount() = " << ci->getPropertyCount() << endl;
    for (int i=0,s=ci->getPropertyCount(); i<s; i++) {    for (int i=0,s=ci->getPropertyCount(); i<s; i++) {
   //cout << ci->getProperty(i).getName ().getString ()
   //     << " "
   //     << ci->getProperty(i).getQualifierCount ()
   //     << " "
   //     << ci->getProperty(i).findQualifier(CIMName ("key"))
   //     << endl;
       if (ci->getProperty(i).findQualifier(String("key"))!=PEG_NOT_FOUND) {       if (ci->getProperty(i).findQualifier(String("key"))!=PEG_NOT_FOUND) {
          CIMProperty *cp  = new CIMProperty(ci->getProperty(i));          CIMProperty *cp  = new CIMProperty(ci->getProperty(i));
          jint         jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp);          jint         jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp);
Line 2003 
Line 2078 
    return DEBUG_ConvertCToJava (CIMInstance*, jint, cf);    return DEBUG_ConvertCToJava (CIMInstance*, jint, cf);
 } }
  
   /*
    * Class:     org_pegasus_jmpi_CIMInstance
    * Method:    _getObjectPath
    * Signature: (I)I
    */
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getObjectPath
     (JNIEnv *jEnv, jobject jThs, jint jciCi)
   {
      CIMInstance   *ci     = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciCi);
      CIMObjectPath *copRet = NULL;
   
      try
      {
         if (ci)
         {
            const CIMObjectPath& cop = ci->getPath ();
   
            copRet = new CIMObjectPath (cop);
         }
      }
      Catch (jEnv);
   
      return DEBUG_ConvertCToJava (CIMObjectPath*, jint, copRet);
   }
   
   /*
    * Class:     org_pegasus_jmpi_CIMInstance
    * Method:    _setObjectPath
    * Signature: (II)V
    */
   JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setObjectPath
     (JNIEnv *jEnv, jobject jThs, jint jciCi, jint jciCop)
   {
      CIMInstance   *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciCi);
      CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jciCop);
   
      try
      {
         if (  ci
            && cop
            )
         {
            ci->setPath (*cop);
         }
      }
      Catch (jEnv);
   }
   
   /*
    * Class:     org_pegasus_jmpi_CIMInstance
    * Method:    _getPropertyCount
    * Signature: (I)I
    */
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getPropertyCount
     (JNIEnv *jEnv, jobject jThs, jint jciCi)
   {
      CIMInstance *ci      = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciCi);
      Uint32       ui32Ret = 0;
   
      try
      {
         if (ci)
         {
            ui32Ret = ci->getPropertyCount ();
         }
      }
      Catch (jEnv);
   
      return ui32Ret;
   }
   
   /*
    * Class:     org_pegasus_jmpi_CIMInstance
    * Method:    _getProperty
    * Signature: (II)I
    */
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getPropertyI
     (JNIEnv *jEnv, jobject jThs, jint jciCi, jint ji)
   {
      CIMInstance *ci    = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciCi);
      CIMProperty *cpRet = NULL;
   
      try
      {
         if (ci)
         {
            CIMProperty  cp;
   
            cp = ci->getProperty (ji);
   
            cpRet = new CIMProperty (cp);
         }
      }
      Catch (jEnv);
   
      return DEBUG_ConvertCToJava (CIMProperty*, jint, cpRet);
   }
   
 // ------------------------------------- // -------------------------------------
 // --- // ---
 // -            CIMObjectPath // -            CIMObjectPath
Line 2369 
Line 2542 
    _dataType *dt  = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);    _dataType *dt  = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);
    jstring    str = NULL;    jstring    str = NULL;
  
    if (dt->_type & 0x10) {     if (dt->_type & 0x10)
       char tmp[32];     {
       strcpy(tmp,jTypeToChars[dt->_type-0x10]);        bool   fSuccess = false;
       strcat(tmp,"[]");        String tmp      = _dataType::convertJavaTypeToChars (dt->_type-0x10, &fSuccess);
       str=jEnv->NewStringUTF(tmp);  
         if (!fSuccess)
            return str;
   
         tmp = tmp + "[]";
   
         str = jEnv->NewStringUTF(tmp.getCString());
    }    }
    else if (dt->_type & 0x20) {     else if (dt->_type == 0x20 + 1) // REFERENCE
      {
       String tmp=dt->_refClass+" REF";       String tmp=dt->_refClass+" REF";
   
       str=jEnv->NewStringUTF(tmp.getCString());       str=jEnv->NewStringUTF(tmp.getCString());
    }    }
    else {     else
       str=jEnv->NewStringUTF(jTypeToChars[dt->_type]);     {
         bool  fSuccess = false;
         char *tmp      = _dataType::convertJavaTypeToChars (dt->_type, &fSuccess);
   
         if (!fSuccess)
            return str;
   
         str = jEnv->NewStringUTF(tmp);
    }    }
  
    return str;    return str;
Line 2396 
Line 2584 
    DEBUG_ConvertCleanup (jint, jDt);    DEBUG_ConvertCleanup (jint, jDt);
 } }
  
 CIMType toPtype (int jType)  
 {  
   if (jType > 13)  
      return (CIMType)14;  
   return  
      (CIMType)(jTypeToPType[jType]);  
 }  
   
  
 // ------------------------------------- // -------------------------------------
 // --- // ---
Line 2488 
Line 2668 
    CIMParamValue *cp   = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP);    CIMParamValue *cp   = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP);
    const CIMValue cv   = cp->getValue();    const CIMValue cv   = cp->getValue();
    String         ref;    String         ref;
    _dataType     *type = new _dataType(pTypeToJType[cv.getType()],     bool           fSuccess = false;
      int            iJType   = 0;
      _dataType     *type     = 0;
   
      iJType = _dataType::convertCTypeToJavaType (cv.getType(), &fSuccess);
   
      if (fSuccess)
      {
         type = new _dataType (iJType,
                                        cv.getArraySize(),                                        cv.getArraySize(),
                                        false,                                        false,
                                        false,                                        false,
                                        cv.isArray(),                                        cv.isArray(),
                                        ref,                                        ref,
                                        true);                                        true);
      }
  
    return DEBUG_ConvertCToJava (_dataType*, jint, type);    return DEBUG_ConvertCToJava (_dataType*, jint, type);
 } }
Line 2681 
Line 2870 
          darr.append(d);          darr.append(d);
       }       }
       break;       break;
      case CIMTYPE_CHAR16: {
            Char16 c16;
            cvin->get(c16);
            Array<Char16> c16arr;
            cv.get(c16arr);
            c16arr.append(c16);
         }
         break;
    case CIMTYPE_STRING: {    case CIMTYPE_STRING: {
          String str;          String str;
          cvin->get(str);          cvin->get(str);
Line 2689 
Line 2886 
          strarr.append(str);          strarr.append(str);
       }       }
       break;       break;
      case CIMTYPE_DATETIME: {
            CIMDateTime dt;
            cvin->get(dt);
            Array<CIMDateTime> dtarr;
            cv.get(dtarr);
            dtarr.append(dt);
         }
         break;
    case CIMTYPE_REFERENCE: {    case CIMTYPE_REFERENCE: {
          CIMObjectPath ref;          CIMObjectPath ref;
          cvin->get(ref);          cvin->get(ref);
Line 2764 
Line 2969 
 { {
    CIMProperty  *cp   = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);    CIMProperty  *cp   = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
    String        ref  = cp->getReferenceClassName().getString();    String        ref  = cp->getReferenceClassName().getString();
    _dataType    *type = new _dataType(pTypeToJType[cp->getType()],     bool           fSuccess = false;
      int            iJType   = 0;
      _dataType     *type     = 0;
   
      iJType = _dataType::convertCTypeToJavaType (cp->getType(), &fSuccess);
   
      if (fSuccess)
      {
         type = new _dataType (iJType,
                                       cp->getArraySize(),                                       cp->getArraySize(),
                                       ref.size() ? true : false,                                       ref.size() ? true : false,
                                       false,                                       false,
                                       cp->isArray(),                                       cp->isArray(),
                                       ref,                                       ref,
                                       true);                                       true);
      }
  
    return DEBUG_ConvertCToJava (_dataType*, jint, type);    return DEBUG_ConvertCToJava (_dataType*, jint, type);
 } }
Line 2779 
Line 2993 
       (JNIEnv *jEnv, jobject jThs, jint jP, jint jDt)       (JNIEnv *jEnv, jobject jThs, jint jP, jint jDt)
 { {
    CIMProperty  *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);    CIMProperty  *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
    _dataType    *dt = (_dataType*)jDt;     _dataType    *dt       = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);
    CIMValue      val;    CIMValue      val;
      bool          fSuccess = false;
      CIMType       cType    = CIMTYPE_BOOLEAN;
  
    val.setNullValue(toPtype(dt->_type),dt->_array);     cType = _dataType::convertJavaTypeToCType (dt->_type, &fSuccess);
   
      if (fSuccess)
      {
         val.setNullValue (cType, dt->_array);
  
    CIMProperty *np = new CIMProperty(cp->getName(),val);    CIMProperty *np = new CIMProperty(cp->getName(),val);
  
    delete cp;    delete cp;
  
         DEBUG_ConvertCleanup (jint, jP);
   
    return DEBUG_ConvertCToJava (CIMProperty*, jint, np);    return DEBUG_ConvertCToJava (CIMProperty*, jint, np);
 } }
      else
      {
         return DEBUG_ConvertCToJava (CIMProperty*, jint, cp);
      }
   }
  
 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)
Line 2811 
Line 3038 
    DEBUG_ConvertCleanup (jint, jP);    DEBUG_ConvertCleanup (jint, jP);
 } }
  
   /*
    * Class:     org_pegasus_jmpi_CIMProperty
    * Method:    _findQualifier
    * Signature: (Ljava/lang/String;)I
    */
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1findQualifier
     (JNIEnv *jEnv, jobject jThs, jint jP, jstring jQualifier)
   {
      CIMProperty  *cp    = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
      const char   *str   = jEnv->GetStringUTFChars (jQualifier, NULL);
      int           index = PEG_NOT_FOUND;
   
      try
      {
         index = cp->findQualifier (CIMName (str));
   
         jEnv->ReleaseStringUTFChars (jQualifier, str);
      }
      Catch (jEnv);
   
      return index;
   }
   
   /*
    * Class:     org_pegasus_jmpi_CIMProperty
    * Method:    _getQualifier
    * Signature: (I)I
    */
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getQualifier
     (JNIEnv *jEnv, jobject jThs, jint jP, jint jIndex)
   {
      CIMProperty  *cp        = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
      CIMQualifier *cq        = NULL;
      CIMQualifier  qualifier;
   
      try
      {
         qualifier = cp->getQualifier ((Uint32)jIndex);
         cq = new CIMQualifier (qualifier);
      }
      Catch (jEnv);
   
      return DEBUG_ConvertCToJava (CIMQualifier *, jint, cq);
   }
   
   
 // ------------------------------------- // -------------------------------------
 // --- // ---
 // -     CIMQualifierType // -     CIMQualifierType
Line 2996 
Line 3269 
 { {
    CIMMethod *cm = DEBUG_ConvertJavaToC (jint, CIMMethod*, jM);    CIMMethod *cm = DEBUG_ConvertJavaToC (jint, CIMMethod*, jM);
  
    return DEBUG_ConvertCToJava (CIMType, jint, new CIMType (cm->getType()));     return DEBUG_ConvertCToJava (CIMType *, jint, new CIMType (cm->getType()));
 } }
  
 JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize
Line 3042 
Line 3315 
    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
 } }
  
 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue_makeInt  JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1makeInt
       (JNIEnv *jEnv, jobject jThs, jlong ji, jboolean notSigned)       (JNIEnv *jEnv, jobject jThs, jlong ji, jboolean notSigned)
 { {
    CIMValue *cv = NULL;    CIMValue *cv = NULL;
Line 3095 
Line 3368 
    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
 } }
  
 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1ref  JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1cop
       (JNIEnv *jEnv, jobject jThs, jint jR)       (JNIEnv *jEnv, jobject jThs, jint jR)
 { {
    CIMObjectPath *ref = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jR);    CIMObjectPath *ref = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jR);
Line 3113 
Line 3386 
    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
 } }
  
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1char16
         (JNIEnv *jEnv, jobject jThs, jchar jChar16)
   {
      Char16       c16 (jChar16);
      CIMValue    *cv  = new CIMValue(c16);
   
      return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
   }
   
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1object
         (JNIEnv *jEnv, jobject jThs, jint jO)
   {
      CIMObject *co = DEBUG_ConvertJavaToC (jint, CIMObject*, jO);
      CIMValue  *cv = new CIMValue(*co);
   
      return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
   }
   
 JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMValue__1isArray JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMValue__1isArray
       (JNIEnv *jEnv, jobject jThs, jint jP)       (JNIEnv *jEnv, jobject jThs, jint jP)
 { {
Line 3150 
Line 3441 
       cv=new CIMValue(s8);       cv=new CIMValue(s8);
    }    }
  
      jEnv->ReleaseShortArrayElements(jshortA, jsA, len);
   
    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
 } }
  
Line 3174 
Line 3467 
       cv=new CIMValue(s16);       cv=new CIMValue(s16);
    }    }
  
      jEnv->ReleaseIntArrayElements(jintA, jiA, len);
   
    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
 } }
  
Line 3198 
Line 3493 
       cv=new CIMValue(s32);       cv=new CIMValue(s32);
    }    }
  
      jEnv->ReleaseLongArrayElements(jlongA, jlA, len);
   
    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
 } }
  
Line 3222 
Line 3519 
       cv=new CIMValue(s64);       cv=new CIMValue(s64);
    }    }
  
      jEnv->ReleaseLongArrayElements(jlongA, jlA, len);
   
    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
 } }
  
Line 3229 
Line 3528 
       (JNIEnv *jEnv, jobject jThs, jobjectArray jstringA)       (JNIEnv *jEnv, jobject jThs, jobjectArray jstringA)
 { {
    CIMValue     *cv   = NULL;    CIMValue     *cv   = NULL;
    jboolean      b;  
    jsize         len  = jEnv->GetArrayLength(jstringA);    jsize         len  = jEnv->GetArrayLength(jstringA);
    Array<String> strA;    Array<String> strA;
  
Line 3260 
Line 3558 
       bA.append((Boolean)jbA[i]);       bA.append((Boolean)jbA[i]);
    cv=new CIMValue(bA);    cv=new CIMValue(bA);
  
      jEnv->ReleaseBooleanArrayElements(jboolA, jbA, len);
   
    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
 } }
  
 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1refArray  JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1floatArray
       (JNIEnv *jEnv, jobject jThs, jintArray jintA)    (JNIEnv *jEnv, jobject jThs, jfloatArray jfloatA)
 { {
    CIMValue             *cv  = NULL;    CIMValue             *cv  = NULL;
    jboolean              b;    jboolean              b;
    jsize                 len = jEnv->GetArrayLength(jintA);     jsize         len = jEnv->GetArrayLength(jfloatA);
    jint                 *jiA = jEnv->GetIntArrayElements(jintA,&b);     jfloat       *jfA = jEnv->GetFloatArrayElements(jfloatA,&b);
    Array<CIMObjectPath>  cA;     Array<float>  fA;
  
    for (jsize i=0;i<len;i++)    for (jsize i=0;i<len;i++)
       cA.append(*((CIMObjectPath*)jiA[i]));        fA.append((float)jfA[i]);
    cv=new CIMValue(cA);     cv=new CIMValue(fA);
   
      jEnv->ReleaseFloatArrayElements(jfloatA, jfA, len);
  
    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
 } }
  
 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType  JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1doubleArray
       (JNIEnv *jEnv, jobject jThs, jint jP)    (JNIEnv *jEnv, jobject jThs, jdoubleArray jdoubleA)
 { {
    CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jP);     CIMValue      *cv  = NULL;
      jboolean       b;
      jsize          len = jEnv->GetArrayLength(jdoubleA);
      jdouble       *jdA = jEnv->GetDoubleArrayElements(jdoubleA,&b);
      Array<double>  dA;
  
    return DEBUG_ConvertCToJava (int, jint, pTypeToJType[cv->getType()]);     for (jsize i=0;i<len;i++)
 }        dA.append((double)jdA[i]);
      cv=new CIMValue(dA);
  
 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString     jEnv->ReleaseDoubleArrayElements(jdoubleA, jdA, len);
       (JNIEnv *jEnv, jobject jThs, jint jV)  
 {  
    CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);  
  
    return (jstring)jEnv->NewStringUTF(cv->toString().getCString());     return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
 } }
  
 JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMValue__1getValue  JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1copArray
       (JNIEnv *jEnv, jobject jThs, jint jV)        (JNIEnv *jEnv, jobject jThs, jintArray jintA)
   {
      CIMValue             *cv  = NULL;
      jboolean              b;
      jsize                 len = jEnv->GetArrayLength(jintA);
      jint                 *jiA = jEnv->GetIntArrayElements(jintA,&b);
      Array<CIMObjectPath>  cA;
   
      for (jsize i=0;i<len;i++)
         cA.append(*((CIMObjectPath*)jiA[i]));
      cv=new CIMValue(cA);
   
      jEnv->ReleaseIntArrayElements(jintA, jiA, len);
   
      return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
   }
   
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1datetimeArray
         (JNIEnv *jEnv, jobject jThs, jintArray jintA)
   {
      CIMValue           *cv  = NULL;
      jboolean            b;
      jsize               len = jEnv->GetArrayLength(jintA);
      jint               *jiA = jEnv->GetIntArrayElements(jintA,&b);
      Array<CIMDateTime>  cA;
   
      for (jsize i=0;i<len;i++)
         cA.append(*((CIMDateTime*)jiA[i]));
      cv=new CIMValue(cA);
   
      jEnv->ReleaseIntArrayElements(jintA, jiA, len);
   
      return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
   }
   
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1objectArray
         (JNIEnv *jEnv, jobject jThs, jintArray jintA)
   {
      CIMValue           *cv  = NULL;
      jboolean            b;
      jsize               len = jEnv->GetArrayLength(jintA);
      jint               *jiA = jEnv->GetIntArrayElements(jintA,&b);
      Array<CIMObject>    cA;
   
      for (jsize i=0;i<len;i++)
         cA.append(*((CIMObject*)jiA[i]));
      cv=new CIMValue(cA);
   
      jEnv->ReleaseIntArrayElements(jintA, jiA, len);
   
      return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
   }
   
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1char16Array
         (JNIEnv *jEnv, jobject jThs, jcharArray jcharA)
   {
      CIMValue      *cv  = NULL;
      jboolean       b;
      jsize          len = jEnv->GetArrayLength(jcharA);
      jchar         *jcA = jEnv->GetCharArrayElements(jcharA,&b);
      Array<Char16>  cA;
   
      for (jsize i=0;i<len;i++)
         cA.append(Char16 (jcA[i]));
      cv=new CIMValue(cA);
   
      jEnv->ReleaseCharArrayElements(jcharA, jcA, len);
   
      return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
   }
   
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType
         (JNIEnv *jEnv, jobject jThs, jint jP)
   {
      CIMValue *cv       = DEBUG_ConvertJavaToC (jint, CIMValue*, jP);
      bool      fSuccess = false;
      int       iJType   = 0;
   
      iJType = _dataType::convertCTypeToJavaType (cv->getType(), &fSuccess);
   
      return DEBUG_ConvertCToJava (int, jint, iJType);
   }
   
   JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString
         (JNIEnv *jEnv, jobject jThs, jint jV)
   {
      CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);
   
      return (jstring)jEnv->NewStringUTF(cv->toString().getCString());
   }
   
   JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMValue__1getValue
         (JNIEnv *jEnv, jobject jThs, jint jV)
 { {
    JMPIjvm::cacheIDs(jEnv);    JMPIjvm::cacheIDs(jEnv);
  
Line 3307 
Line 3703 
  
    CIMType type=cv->getType();    CIMType type=cv->getType();
  
    if (!cv->isArray()) {     if (!cv->isArray ())
       switch (type) {     {
         switch (type)
         {
       case CIMTYPE_BOOLEAN:       case CIMTYPE_BOOLEAN:
          Boolean bo;          Boolean bo;
          cv->get(bo);          cv->get(bo);
          return jEnv->NewObject(JMPIjvm::jv.BooleanClassRef,JMPIjvm::jv.BooleanNewZ,bo);           return jEnv->NewObject (JMPIjvm::jv.BooleanClassRef,
          break;                                   JMPIjvm::jv.BooleanNewZ,
                                    bo);
       case CIMTYPE_SINT8:       case CIMTYPE_SINT8:
          Sint8 s8;          Sint8 s8;
          cv->get(s8);          cv->get(s8);
          return jEnv->NewObject(JMPIjvm::jv.ByteClassRef,JMPIjvm::jv.ByteNewB,s8);           return jEnv->NewObject (JMPIjvm::jv.ByteClassRef,
          break;                                   JMPIjvm::jv.ByteNewB,
                                    s8);
       case CIMTYPE_UINT8:       case CIMTYPE_UINT8:
          Uint8 u8;          Uint8 u8;
          cv->get(u8);          cv->get(u8);
          return jEnv->NewObject(JMPIjvm::jv.UnsignedInt8ClassRef,JMPIjvm::jv.UnsignedInt8NewS,u8);           return jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef,
          break;                                   JMPIjvm::jv.UnsignedInt8NewS,
                                    u8);
       case CIMTYPE_SINT16:       case CIMTYPE_SINT16:
          Sint16 s16;          Sint16 s16;
          cv->get(s16);          cv->get(s16);
          return jEnv->NewObject(JMPIjvm::jv.ShortClassRef,JMPIjvm::jv.ShortNewS,s16);           return jEnv->NewObject (JMPIjvm::jv.ShortClassRef,
          break;                                   JMPIjvm::jv.ShortNewS,
                                    s16);
       case CIMTYPE_UINT16:       case CIMTYPE_UINT16:
          Uint16 u16;          Uint16 u16;
          cv->get(u16);          cv->get(u16);
          return jEnv->NewObject(JMPIjvm::jv.UnsignedInt16ClassRef,JMPIjvm::jv.UnsignedInt16NewI,u16);           return jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef,
          break;                                   JMPIjvm::jv.UnsignedInt16NewI,
                                    u16);
       case CIMTYPE_SINT32:       case CIMTYPE_SINT32:
          Sint32 s32;          Sint32 s32;
          cv->get(s32);          cv->get(s32);
          return jEnv->NewObject(JMPIjvm::jv.IntegerClassRef,JMPIjvm::jv.IntegerNewI,s32);           return jEnv->NewObject (JMPIjvm::jv.IntegerClassRef,
          break;                                   JMPIjvm::jv.IntegerNewI,
                                    s32);
       case CIMTYPE_UINT32:       case CIMTYPE_UINT32:
          Uint32 u32;          Uint32 u32;
          cv->get(u32);          cv->get(u32);
          return jEnv->NewObject(JMPIjvm::jv.UnsignedInt32ClassRef,JMPIjvm::jv.UnsignedInt32NewJ,u32);           return jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef,
          break;                                   JMPIjvm::jv.UnsignedInt32NewJ,
                                    u32);
       case CIMTYPE_SINT64:       case CIMTYPE_SINT64:
          Sint64 s64;          Sint64 s64;
          cv->get(s64);          cv->get(s64);
          return jEnv->NewObject(JMPIjvm::jv.LongClassRef,JMPIjvm::jv.LongNewJ,s64);           return jEnv->NewObject (JMPIjvm::jv.LongClassRef,
          break;                                   JMPIjvm::jv.LongNewJ,
       case CIMTYPE_UINT64: {                                   s64);
         case CIMTYPE_UINT64:
         {
             Uint64 u64;             Uint64 u64;
             cv->get(u64);             cv->get(u64);
             jobject big=jEnv->CallStaticObjectMethod(JMPIjvm::jv.BigIntegerClassRef,JMPIjvm::jv.BigIntegerValueOf,u64);           jobject jBIG = jEnv->CallStaticObjectMethod (JMPIjvm::jv.BigIntegerClassRef,
             return jEnv->NewObject(JMPIjvm::jv.UnsignedInt64ClassRef,JMPIjvm::jv.UnsignedInt64NewBi,big);                                                        JMPIjvm::jv.BigIntegerValueOf,
                                                         u64);
            return jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,
                                    JMPIjvm::jv.UnsignedInt64NewBi,
                                    jBIG);
          }          }
          break;  
       case CIMTYPE_REAL32:       case CIMTYPE_REAL32:
          float f;          float f;
          cv->get(f);          cv->get(f);
          return jEnv->NewObject(JMPIjvm::jv.FloatClassRef,JMPIjvm::jv.FloatNewF,f);           return jEnv->NewObject (JMPIjvm::jv.FloatClassRef,
          break;                                   JMPIjvm::jv.FloatNewF,
                                    f);
       case CIMTYPE_REAL64:       case CIMTYPE_REAL64:
          double d;          double d;
          cv->get(d);          cv->get(d);
          return jEnv->NewObject(JMPIjvm::jv.DoubleClassRef,JMPIjvm::jv.DoubleNewD,d);           return jEnv->NewObject (JMPIjvm::jv.DoubleClassRef,
          break;                                   JMPIjvm::jv.DoubleNewD,
       case CIMTYPE_STRING: {                                   d);
         case CIMTYPE_STRING:
         {
             String s;             String s;
             jstring str;  
             cv->get(s);             cv->get(s);
             str=jEnv->NewStringUTF(s.getCString());           return jEnv->NewStringUTF(s.getCString());
             return str;  
          }          }
          break;        case CIMTYPE_REFERENCE:
       case CIMTYPE_REFERENCE:  {        {
             CIMObjectPath ref;             CIMObjectPath ref;
             cv->get(ref);             cv->get(ref);
             jint jOp = DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(ref));             jint jOp = DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(ref));
             return jEnv->NewObject(JMPIjvm::jv.CIMObjectPathClassRef,JMPIjvm::jv.CIMObjectPathNewI,jOp);           return jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef,
                                    JMPIjvm::jv.CIMObjectPathNewI,
                                    jOp);
          }          }
          break;  
       case CIMTYPE_CHAR16:       case CIMTYPE_CHAR16:
          throwCIMException(jEnv,"+++ Char16 not yet supported");        {
          break;           Char16 c16;
       case CIMTYPE_DATETIME: {           cv->get(c16);
            return jEnv->NewObject (JMPIjvm::jv.CharacterClassRef,
                                    JMPIjvm::jv.CharacterNewC,
                                    (jchar)c16);
         }
         case CIMTYPE_DATETIME:
         {
             CIMDateTime dt;             CIMDateTime dt;
             cv->get(dt);             cv->get(dt);
             jint jDT = DEBUG_ConvertCToJava (CIMDateTime*, jint, new CIMDateTime(dt));             jint jDT = DEBUG_ConvertCToJava (CIMDateTime*, jint, new CIMDateTime(dt));
             return jEnv->NewObject(JMPIjvm::jv.CIMDateTimeClassRef,JMPIjvm::jv.CIMDateTimeNewI,jDT);           return jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef,
                                    JMPIjvm::jv.CIMDateTimeNewI,
                                    jDT);
          }          }
          break;  
       case CIMTYPE_OBJECT:       case CIMTYPE_OBJECT:
          throwCIMException(jEnv,"+++ Object not yet supported");        {
          break;           CIMObject co;
            cv->get(co);
            if (co.isClass ())
            {
               jint jCC = DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass(co));
   
               return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,
                                       JMPIjvm::jv.CIMObjectNewIZ,
                                       jCC,
                                       (jboolean)true);
            }
            else
            {
               jint jCI = DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance(co));
   
               return jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,
                                       JMPIjvm::jv.CIMObjectNewIZ,
                                       jCI,
                                       (jboolean)false);
            }
         }
       default:       default:
          throwCIMException(jEnv,"+++ unsupported type: ");          throwCIMException(jEnv,"+++ unsupported type: ");
       }       }
    }    }
    else {     else
       switch (type) {     {
       case CIMTYPE_BOOLEAN: {        switch (type)
         {
         case CIMTYPE_BOOLEAN:
         {
             Array<Boolean> bo;             Array<Boolean> bo;
   
             cv->get(bo);             cv->get(bo);
   
             int s=bo.size();             int s=bo.size();
             jobjectArray jbooleanA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.BooleanClassRef,0);           jobjectArray jbooleanA = (jobjectArray)jEnv->NewObjectArray (s,
             for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jbooleanA, i,                                                                        JMPIjvm::jv.BooleanClassRef,
                   jEnv->NewObject(JMPIjvm::jv.BooleanClassRef,JMPIjvm::jv.BooleanNewZ,bo[i]));                                                                        0);
   
            for (int i=0; i < s; i++)
               jEnv->SetObjectArrayElement(jbooleanA,
                                           i,
                                           jEnv->NewObject (JMPIjvm::jv.BooleanClassRef,
                                                            JMPIjvm::jv.BooleanNewZ,
                                                            bo[i]));
             return jbooleanA;             return jbooleanA;
          }          }
          break;        case CIMTYPE_SINT8:
       case CIMTYPE_SINT8: {        {
             Array<Sint8> s8;             Array<Sint8> s8;
   
             cv->get(s8);             cv->get(s8);
   
             int s=s8.size();             int s=s8.size();
             jobjectArray jbyteA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.ByteClassRef,0);           jobjectArray jbyteA = (jobjectArray)jEnv->NewObjectArray (s,
             for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jbyteA, i,                                                                     JMPIjvm::jv.ByteClassRef,
                jEnv->NewObject(JMPIjvm::jv.ByteClassRef,JMPIjvm::jv.ByteNewB,s8[i]));                                                                     0);
   
            for (int i=0; i < s; i++)
               jEnv->SetObjectArrayElement (jbyteA,
                                            i,
                                            jEnv->NewObject (JMPIjvm::jv.ByteClassRef,
                                                             JMPIjvm::jv.ByteNewB,
                                                             s8[i]));
             return jbyteA;             return jbyteA;
          }          }
          break;        case CIMTYPE_UINT8:
       case CIMTYPE_UINT8: {        {
             Array<Uint8> u8;             Array<Uint8> u8;
   
             cv->get(u8);             cv->get(u8);
   
             int s=u8.size();             int s=u8.size();
             jobjectArray jshortA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.UnsignedInt8ClassRef,0);           jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray (s,
             for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jshortA, i,                                                                      JMPIjvm::jv.UnsignedInt8ClassRef,
                jEnv->NewObject(JMPIjvm::jv.UnsignedInt8ClassRef,JMPIjvm::jv.UnsignedInt8NewS,u8[i]));                                                                      0);
            for (int i=0; i < s; i++)
               jEnv->SetObjectArrayElement (jshortA,
                                            i,
                                            jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef,
                                                             JMPIjvm::jv.UnsignedInt8NewS,
                                                             u8[i]));
             return jshortA;             return jshortA;
          }          }
          break;        case CIMTYPE_SINT16:
       case CIMTYPE_SINT16: {        {
             Array<Sint16> s16;             Array<Sint16> s16;
   
             cv->get(s16);             cv->get(s16);
   
             int s=s16.size();             int s=s16.size();
             jobjectArray jshortA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.ShortClassRef,0);           jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray (s,
             for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jshortA, i,                                                                      JMPIjvm::jv.ShortClassRef,
                jEnv->NewObject(JMPIjvm::jv.ShortClassRef,JMPIjvm::jv.ShortNewS,s16[i]));                                                                      0);
   
            for (int i=0; i < s; i++)
               jEnv->SetObjectArrayElement (jshortA,
                                            i,
                                            jEnv->NewObject (JMPIjvm::jv.ShortClassRef,
                                                             JMPIjvm::jv.ShortNewS,
                                                             s16[i]));
             return jshortA;             return jshortA;
          }          }
          break;        case CIMTYPE_UINT16:
       case CIMTYPE_UINT16: {        {
             Array<Uint16> u16;             Array<Uint16> u16;
   
             cv->get(u16);             cv->get(u16);
   
             int s=u16.size();             int s=u16.size();
             jobjectArray jintA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.UnsignedInt16ClassRef,0);           jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray (s,
             for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jintA, i,                                                                    JMPIjvm::jv.UnsignedInt16ClassRef,
                jEnv->NewObject(JMPIjvm::jv.UnsignedInt16ClassRef,JMPIjvm::jv.UnsignedInt16NewI,u16[i]));                                                                    0);
   
            for (int i=0; i < s; i++)
               jEnv->SetObjectArrayElement (jintA,
                                            i,
                                            jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef,
                                                             JMPIjvm::jv.UnsignedInt16NewI,
                                                             u16[i]));
             return jintA;             return jintA;
          }          }
          break;        case CIMTYPE_SINT32:
       case CIMTYPE_SINT32: {        {
             Array<Sint32> s32;             Array<Sint32> s32;
   
             cv->get(s32);             cv->get(s32);
   
             int s=s32.size();             int s=s32.size();
             jobjectArray jintA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.IntegerClassRef,0);           jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray (s,
             for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jintA, i,                                                                    JMPIjvm::jv.IntegerClassRef,
                jEnv->NewObject(JMPIjvm::jv.IntegerClassRef,JMPIjvm::jv.IntegerNewI,s32[i]));                                                                    0);
   
            for (int i=0; i < s; i++)
               jEnv->SetObjectArrayElement (jintA,
                                            i,
                                            jEnv->NewObject (JMPIjvm::jv.IntegerClassRef,
                                                             JMPIjvm::jv.IntegerNewI,
                                                             s32[i]));
             return jintA;             return jintA;
          }          }
          break;        case CIMTYPE_UINT32:
       case CIMTYPE_UINT32: {        {
             Array<Uint32> u32;             Array<Uint32> u32;
   
             cv->get(u32);             cv->get(u32);
   
             int s=u32.size();             int s=u32.size();
             jobjectArray jlongA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.UnsignedInt32ClassRef,0);           jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray (s,
             for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jlongA, i,                                                                     JMPIjvm::jv.UnsignedInt32ClassRef,
                jEnv->NewObject(JMPIjvm::jv.UnsignedInt32ClassRef,JMPIjvm::jv.UnsignedInt32NewJ,u32[i]));                                                                     0);
   
            for (int i=0; i < s; i++)
               jEnv->SetObjectArrayElement (jlongA,
                                            i,
                                            jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef,
                                                             JMPIjvm::jv.UnsignedInt32NewJ,
                                                             u32[i]));
             return jlongA;             return jlongA;
          }          }
          break;        case CIMTYPE_SINT64:
       case CIMTYPE_SINT64: {        {
             Array<Sint64> s64;             Array<Sint64> s64;
   
             cv->get(s64);             cv->get(s64);
   
             int s=s64.size();             int s=s64.size();
             jobjectArray jlongA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.LongClassRef,0);           jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray (s,
             for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jlongA, i,                                                                     JMPIjvm::jv.LongClassRef,
                jEnv->NewObject(JMPIjvm::jv.LongClassRef,JMPIjvm::jv.LongNewJ,s64[i]));                                                                     0);
   
            for (int i=0; i < s; i++)
               jEnv->SetObjectArrayElement (jlongA,
                                            i,
                                            jEnv->NewObject (JMPIjvm::jv.LongClassRef,
                                                             JMPIjvm::jv.LongNewJ,
                                                             s64[i]));
             return jlongA;             return jlongA;
          }          }
          break;  
       case CIMTYPE_UINT64:       case CIMTYPE_UINT64:
          throwCIMException(jEnv,"+++ UnisgnetInt64 not yet supported");        {
          break;           Array<Uint64> u64;
       case CIMTYPE_REAL32: {  
            cv->get(u64);
   
            int          s     = u64.size();
            jobjectArray ju64A = (jobjectArray)jEnv->NewObjectArray (s,
                                                                     JMPIjvm::jv.UnsignedInt64ClassRef,
                                                                     0);
   
            for (int i=0; i < s; i++)
            {
               jobject jBIG = jEnv->CallStaticObjectMethod (JMPIjvm::jv.BigIntegerClassRef,
                                                            JMPIjvm::jv.BigIntegerValueOf,
                                                            u64[i]);
   
               jEnv->SetObjectArrayElement (ju64A,
                                            i,
                                            jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,
                                                             JMPIjvm::jv.UnsignedInt64NewBi,
                                                             jBIG));
            }
            return ju64A;
         }
         case CIMTYPE_REAL32:
         {
             Array<Real32> r32;             Array<Real32> r32;
   
             cv->get(r32);             cv->get(r32);
   
             int s=r32.size();             int s=r32.size();
             jobjectArray jfloatA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.FloatClassRef,0);           jobjectArray jfloatA = (jobjectArray)jEnv->NewObjectArray (s,
             for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jfloatA, i,                                                                      JMPIjvm::jv.FloatClassRef,
                jEnv->NewObject(JMPIjvm::jv.FloatClassRef,JMPIjvm::jv.FloatNewF,r32[i]));                                                                      0);
   
            for (int i=0; i < s; i++)
               jEnv->SetObjectArrayElement (jfloatA,
                                            i,
                                            jEnv->NewObject (JMPIjvm::jv.FloatClassRef,
                                                             JMPIjvm::jv.FloatNewF,
                                                             r32[i]));
             return jfloatA;             return jfloatA;
          }          }
          break;        case CIMTYPE_REAL64:
       case CIMTYPE_REAL64: {        {
             Array<Real64> r64;             Array<Real64> r64;
   
             cv->get(r64);             cv->get(r64);
   
             int s=r64.size();             int s=r64.size();
             jobjectArray jdoubleA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.DoubleClassRef,0);           jobjectArray jdoubleA = (jobjectArray)jEnv->NewObjectArray (s,
             for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jdoubleA, i,                                                                       JMPIjvm::jv.DoubleClassRef,
                jEnv->NewObject(JMPIjvm::jv.DoubleClassRef,JMPIjvm::jv.DoubleNewD,r64[i]));                                                                       0);
   
            for (int i=0; i < s; i++)
               jEnv->SetObjectArrayElement (jdoubleA,
                                            i,
                                            jEnv->NewObject (JMPIjvm::jv.DoubleClassRef,
                                                             JMPIjvm::jv.DoubleNewD,
                                                             r64[i]));
             return jdoubleA;             return jdoubleA;
          }          }
          break;        case CIMTYPE_STRING:
       case CIMTYPE_STRING: {        {
             Array<String> str;             Array<String> str;
   
             cv->get(str);             cv->get(str);
   
             int s=str.size();             int s=str.size();
             jobjectArray jstringA=(jobjectArray)jEnv->NewObjectArray(s,JMPIjvm::jv.StringClassRef,0);           jobjectArray jstringA = (jobjectArray)jEnv->NewObjectArray (s,
             for (int i=0; i < s; i++) jEnv->SetObjectArrayElement(jstringA, i,                                                                       JMPIjvm::jv.StringClassRef,
                                                                        0);
   
            for (int i=0; i < s; i++)
               jEnv->SetObjectArrayElement (jstringA,
                                            i,
                jEnv->NewStringUTF(str[i].getCString()));                jEnv->NewStringUTF(str[i].getCString()));
             return jstringA;             return jstringA;
          }          }
          break;  
       case CIMTYPE_REFERENCE:       case CIMTYPE_REFERENCE:
          throwCIMException(jEnv,"+++ Reference not yet supported");        {
          break;           Array<CIMObjectPath> ref;
   
            cv->get(ref);
   
            int          s     = ref.size();
            jobjectArray jrefA = (jobjectArray)jEnv->NewObjectArray (s,
                                                                     JMPIjvm::jv.CIMObjectPathClassRef,
                                                                     0);
   
            for (int i=0; i < s; i++)
            {
               jint jOP = DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath(ref[i]));
   
               jEnv->SetObjectArrayElement (jrefA,
                                            i,
                                            jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef,
                                                             JMPIjvm::jv.CIMObjectPathNewI,
                                                             jOP));
            }
            return jrefA;
         }
       case CIMTYPE_CHAR16:       case CIMTYPE_CHAR16:
          throwCIMException(jEnv,"+++ Char16 not yet supported");        {
          break;           Array<Char16> c16;
   
            cv->get(c16);
   
            int          s     = c16.size();
            jobjectArray jc16A = (jobjectArray)jEnv->NewObjectArray (s,
                                                                     JMPIjvm::jv.CharacterClassRef,
                                                                     0);
   
            for (int i=0; i < s; i++)
               jEnv->SetObjectArrayElement (jc16A,
                                            i,
                                            jEnv->NewObject (JMPIjvm::jv.CharacterClassRef,
                                                             JMPIjvm::jv.CharacterNewC,
                                                             (jchar)c16[i]));
   
            return jc16A;
         }
       case CIMTYPE_DATETIME:       case CIMTYPE_DATETIME:
          throwCIMException(jEnv,"+++ DateTime not yet supported");        {
          break;           Array<CIMDateTime> dt;
   
            cv->get(dt);
   
            int          s    = dt.size();
            jobjectArray jdtA = (jobjectArray)jEnv->NewObjectArray (s,
                                                                    JMPIjvm::jv.CIMDateTimeClassRef,
                                                                    0);
   
            for (int i=0; i < s; i++)
            {
               jint jDT = DEBUG_ConvertCToJava (CIMDateTime*, jint, new CIMDateTime(dt[i]));
   
               jEnv->SetObjectArrayElement (jdtA,
                                            i,
                                            jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef,
                                                             JMPIjvm::jv.CIMDateTimeNewI,
                                                             jDT));
            }
            return jdtA;
         }
       case CIMTYPE_OBJECT:       case CIMTYPE_OBJECT:
          throwCIMException(jEnv,"+++ Object not yet supported");        {
          break;           Array<CIMObject> co;
   
            cv->get(co);
   
            int          s    = co.size();
            jobjectArray jcoA = (jobjectArray)jEnv->NewObjectArray (s,
                                                                    JMPIjvm::jv.CIMObjectClassRef,
                                                                    0);
   
            for (int i=0; i < s; i++)
            {
               if (co[i].isClass ())
               {
                  jint jCC = DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass(co[i]));
   
                  jEnv->SetObjectArrayElement (jcoA,
                                               i,
                                               jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,
                                                                JMPIjvm::jv.CIMObjectNewIZ,
                                                                jCC,
                                                                (jboolean)true));
               }
               else
               {
                  jint jCI = DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance(co[i]));
   
                  jEnv->SetObjectArrayElement (jcoA,
                                               i,
                                               jEnv->NewObject (JMPIjvm::jv.CIMObjectClassRef,
                                                                JMPIjvm::jv.CIMObjectNewIZ,
                                                                jCI,
                                                                (jboolean)false));
               }
            }
            return jcoA;
         }
       default:       default:
       throwCIMException(jEnv,"+++ unsupported type: ");       throwCIMException(jEnv,"+++ unsupported type: ");
       }       }
Line 4503 
Line 5154 
    DEBUG_ConvertCleanup (jint, jCc);    DEBUG_ConvertCleanup (jint, jCc);
 } }
  
   // -------------------------------------
   // ---
   // -            CIMObject
   // ---
   // -------------------------------------
   
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObject__1newClass
     (JNIEnv *jEnv, jobject jThs, jint jCc)
   {
      CIMClass *cCc = DEBUG_ConvertJavaToC (jint, CIMClass*, jCc);
   
      try {
         CIMObject *cCo = new CIMObject (*cCc);
   
         return DEBUG_ConvertCToJava (CIMObject*, jint, cCo);
      }
      Catch(jEnv);
   
      return 0;
   }
   
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObject__1newInstance
     (JNIEnv *jEnv, jobject jThs, jint jCi)
   {
      CIMInstance *cCi = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);
   
      try {
         CIMObject *cCo = new CIMObject (*cCi);
   
         return DEBUG_ConvertCToJava (CIMObject*, jint, cCo);
      }
      Catch(jEnv);
   
      return 0;
   }
   
   JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObject__1finalize
     (JNIEnv *jEnv, jobject jThs, jint jInst)
   {
      CIMObject *co = DEBUG_ConvertJavaToC (jint, CIMObject*, jInst);
   
      delete co;
   
      DEBUG_ConvertCleanup (jint, jInst);
   }
   
   // -------------------------------------
   // ---
   // -            OperationContext
   // ---
   // -------------------------------------
   
   /*
    * Class:     OperationContext
    * Method:    _get
    * Signature: (ILjava/lang/String;Ljava/lang/String;)Ljava/lang/Object;
    */
   JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_OperationContext__1get
     (JNIEnv *jEnv, jobject jThs, jint jInst, jstring jContainer, jstring jKey)
   {
      OperationContext *poc  = DEBUG_ConvertJavaToC (jint, OperationContext*, jInst);
      jobject           jRet = 0;
   
      if (!poc)
      {
         return jRet;
      }
   
      const char *pszContainer = jEnv->GetStringUTFChars (jContainer, NULL);
      const char *pszKey       = jEnv->GetStringUTFChars (jKey, NULL);
      String      container (pszContainer);
      String      key       (pszKey);
   
   ///printf ("container: %s\n", pszContainer);
   ///printf ("key: %s\n", pszKey);
   
      try {
         if (container == "IdentityContainer")
         {
            IdentityContainer ic = poc->get (IdentityContainer::NAME);
   
   /////////printf ("ic\n");
   
            if (key == "userName")
            {
               String userName = ic.getUserName ();
   
   ////////////printf ("userName: %s\n", (const char*)userName.getCString ());
   
               jRet = jEnv->NewStringUTF ((const char*)userName.getCString ());
            }
         }
         else if (container == "SubscriptionInstanceContainer")
         {
            SubscriptionInstanceContainer sic = poc->get (SubscriptionInstanceContainer::NAME);
   
            if (key == "subscriptionInstance")
            {
               CIMInstance ci     = sic.getInstance ();
               jint        jciRef = DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance (ci));
   
               jRet = jEnv->NewObject (JMPIjvm::jv.CIMInstanceClassRef,
                                       JMPIjvm::jv.CIMInstanceNewI,
                                       jciRef);
            }
         }
         else if (container == "SubscriptionInstanceNamesContainer")
         {
            SubscriptionInstanceNamesContainer sinc = poc->get (SubscriptionInstanceNamesContainer::NAME);
   
            if (key == "subscriptionInstanceNames")
            {
               Array<CIMObjectPath> copa        = sinc.getInstanceNames ();
               jobjectArray         jcopa       = 0;
               int                  jcopaLength = copa.size ();
   
               jcopa = jEnv->NewObjectArray (jcopaLength,
                                             JMPIjvm::jv.CIMObjectPathClassRef,
                                             0);
   
               for (int i = 0; i < jcopaLength; i++)
               {
                  jEnv->SetObjectArrayElement (jcopa,
                                               i,
                                               jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef,
                                                                JMPIjvm::jv.CIMObjectPathNewI,
                                                                new CIMObjectPath (copa[i])));
               }
   
               jRet = (jobject)jcopa;
            }
         }
         else if (container == "SubscriptionFilterConditionContainer")
         {
            SubscriptionFilterConditionContainer sfcc = poc->get (SubscriptionFilterConditionContainer::NAME);
   
   /////////printf ("sfcc\n");
   
            if (key == "filterCondition")
            {
               String filterCondition = sfcc.getFilterCondition ();
   
   ////////////printf ("filterCondition: %s\n", (const char*)filterCondition.getCString ());
   
               jRet = jEnv->NewStringUTF ((const char*)filterCondition.getCString ());
            }
            else if (key == "queryLanguage")
            {
               String queryLanguage = sfcc.getQueryLanguage ();
   
               jRet = jEnv->NewStringUTF ((const char*)queryLanguage.getCString ());
            }
         }
         else if (container == "SubscriptionFilterQueryContainer")
         {
            SubscriptionFilterQueryContainer sfqc = poc->get (SubscriptionFilterQueryContainer::NAME);
   
            if (key == "filterQuery")
            {
               String filterQuery = sfqc.getFilterQuery ();
   
               jRet = jEnv->NewStringUTF ((const char*)filterQuery.getCString ());
            }
            else if (key == "queryLanguage")
            {
               String queryLanguage = sfqc.getQueryLanguage ();
   
               jRet = jEnv->NewStringUTF ((const char*)queryLanguage.getCString ());
            }
            else if (key == "sourceNameSpace")
            {
               CIMNamespaceName cimNameSpaceName = sfqc.getSourceNameSpace ();
               String           nameSpaceName    = cimNameSpaceName.getString ();
   
               jRet = jEnv->NewStringUTF ((const char*)nameSpaceName.getCString ());
            }
         }
         else if (container == "SnmpTrapOidContainer")
         {
            SnmpTrapOidContainer stoc = poc->get (SnmpTrapOidContainer::NAME);
   
            if (key == "snmpTrapOid")
            {
               String snmpTrapOid = stoc.getSnmpTrapOid ();
   
               jRet = jEnv->NewStringUTF ((const char*)snmpTrapOid.getCString ());
            }
         }
      }
      Catch(jEnv);
   
   ///printf ("jRet: %08X\n", (int)jRet);
   
      jEnv->ReleaseStringUTFChars (jContainer, pszContainer);
      jEnv->ReleaseStringUTFChars (jKey, pszKey);
   
      return jRet;
   }
   
   // -------------------------------------
   // ---
   // -            SelectExp
   // ---
   // -------------------------------------
   
   /*
    * Class:     org_pegasus_jmpi_SelectExp
    * Method:    _finalize
    * Signature: (I)V
    */
   JNIEXPORT void JNICALL Java_org_pegasus_jmpi_SelectExp__1finalize
     (JNIEnv *jEnv, jobject jThs, jint jEselx)
   {
      CMPI_SelectExp *eSelx = DEBUG_ConvertJavaToC (jint, CMPI_SelectExp*, jEselx);
   
      delete eSelx;
   
      DEBUG_ConvertCleanup (jint, jEselx);
   }
   
   /*
    * Class:     org_pegasus_jmpi_SelectExp
    * Method:    _newSelectExp
    * Signature: (Ljava/lang/String;)I
    */
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_SelectExp__1newSelectExp
     (JNIEnv *jEnv, jobject jThs, jstring jQuery)
   {
      const char         *pszQuery = jEnv->GetStringUTFChars (jQuery, NULL);
      CMPI_SelectExp     *eSelx    = NULL;
      WQLSelectStatement *stmt     = NULL;
      String              queryLanguage (CALL_SIGN_WQL);
      String              query (pszQuery);
   
      stmt  = new WQLSelectStatement (queryLanguage, query);
      eSelx = new CMPI_SelectExp (stmt);
   
      jEnv->ReleaseStringUTFChars (jQuery, pszQuery);
   
      return DEBUG_ConvertCToJava (CMPI_SelectExp *, jint, eSelx);
   }
   
   /*
    * Class:     org_pegasus_jmpi_SelectExp
    * Method:    _getSelectString
    * Signature: (I)Ljava/lang/String;
    */
   JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_SelectExp__1getSelectString
     (JNIEnv *jEnv, jobject jThs, jint jEselx)
   {
      CMPI_SelectExp *eSelx = DEBUG_ConvertJavaToC (jint, CMPI_SelectExp*, jEselx);
   
      return (jstring)jEnv->NewStringUTF (eSelx->cond.getCString ());
   }
   
   // -------------------------------------
   // ---
   // -            JMPISelectList
   // ---
   // -------------------------------------
   
   /*
    * Class:     org_pegasus_jmpi_JMPISelectList
    * Method:    _applyInstance
    * Signature: (II)I
    */
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyInstance
     (JNIEnv *jEnv, jobject jThs, jint jEselx, jint jciInstance)
   {
      CMPI_SelectExp *eSelx = DEBUG_ConvertJavaToC (jint, CMPI_SelectExp*, jEselx);
      CIMInstance    *ci    = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciInstance);
      CIMInstance    *ciRet = 0;
   
      if (  !eSelx
         || !eSelx->wql_stmt
         )
      {
         return 0;
      }
   
      ciRet = new CIMInstance (ci->clone ());
   
      if (ciRet)
      {
         eSelx->wql_stmt->applyProjection (*ciRet, false);
      }
   
      return DEBUG_ConvertCToJava (CIMInstance *, jint, ciRet);
   }
   
   /*
    * Class:     org_pegasus_jmpi_JMPISelectList
    * Method:    _applyClass
    * Signature: (II)I
    */
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_JMPISelectList__1applyClass
     (JNIEnv *jEnv, jobject jThs, jint jEselx, jint jciClass)
   {
      CMPI_SelectExp *eSelx = DEBUG_ConvertJavaToC (jint, CMPI_SelectExp*, jEselx);
      CIMClass       *cc    = DEBUG_ConvertJavaToC (jint, CIMClass*, jciClass);
      CIMClass       *ccRet = NULL;
   
      if (  !eSelx
         || !eSelx->wql_stmt
         )
      {
         return 0;
      }
   
      if (cc)
      {
         CIMObject co (cc->clone ());
   
         eSelx->wql_stmt->applyProjection (co, false);
   
         ccRet = new CIMClass (co);
   
         return DEBUG_ConvertCToJava (CIMClass *, jint, ccRet);
      }
   
      return 0;
   }
   
   // -------------------------------------
   // ---
   // -            JMPIQueryExp
   // ---
   // -------------------------------------
   
   /*
    * Class:     org_pegasus_jmpi_JMPIQueryExp
    * Method:    _applyInstance
    * Signature: (II)Z
    */
   JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_JMPIQueryExp__1applyInstance
     (JNIEnv *jEnv, jobject jThs, jint jEselx, jint jciInstance)
   {
      CMPI_SelectExp *eSelx = DEBUG_ConvertJavaToC (jint, CMPI_SelectExp*, jEselx);
      CIMInstance    *ci    = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciInstance);
   
      if (  !eSelx
         || !eSelx->wql_stmt
         )
      {
         return 0;
      }
   
      if (eSelx->wql_stmt)
      {
         return eSelx->wql_stmt->evaluate (*ci);
      }
   
      return false;
   }
   
 } // extern "C" } // extern "C"
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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