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

version 1.32, 2005/12/08 21:34:54 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 707 
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 777 
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 877 
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 903 
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 1030 
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 1402 
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 1897 
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 2042 
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 2408 
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 2435 
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 2527 
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 2720 
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 2728 
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 2803 
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 2818 
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;
   
      cType = _dataType::convertJavaTypeToCType (dt->_type, &fSuccess);
  
    val.setNullValue(toPtype(dt->_type),dt->_array);     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 2850 
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 3035 
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 3081 
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 3134 
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 3152 
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 3189 
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 3213 
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 3237 
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 3261 
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 3268 
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 3299 
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);
   }
   
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1floatArray
     (JNIEnv *jEnv, jobject jThs, jfloatArray jfloatA)
   {
      CIMValue     *cv  = NULL;
      jboolean      b;
      jsize         len = jEnv->GetArrayLength(jfloatA);
      jfloat       *jfA = jEnv->GetFloatArrayElements(jfloatA,&b);
      Array<float>  fA;
   
      for (jsize i=0;i<len;i++)
         fA.append((float)jfA[i]);
      cv=new CIMValue(fA);
   
      jEnv->ReleaseFloatArrayElements(jfloatA, jfA, len);
   
      return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
   }
   
   JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1doubleArray
     (JNIEnv *jEnv, jobject jThs, jdoubleArray jdoubleA)
   {
      CIMValue      *cv  = NULL;
      jboolean       b;
      jsize          len = jEnv->GetArrayLength(jdoubleA);
      jdouble       *jdA = jEnv->GetDoubleArrayElements(jdoubleA,&b);
      Array<double>  dA;
   
      for (jsize i=0;i<len;i++)
         dA.append((double)jdA[i]);
      cv=new CIMValue(dA);
   
      jEnv->ReleaseDoubleArrayElements(jdoubleA, jdA, len);
   
    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
 } }
  
 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1refArray  JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1copArray
       (JNIEnv *jEnv, jobject jThs, jintArray jintA)       (JNIEnv *jEnv, jobject jThs, jintArray jintA)
 { {
    CIMValue             *cv  = NULL;    CIMValue             *cv  = NULL;
Line 3315 
Line 3612 
       cA.append(*((CIMObjectPath*)jiA[i]));       cA.append(*((CIMObjectPath*)jiA[i]));
    cv=new CIMValue(cA);    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);    return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
 } }
  
Line 3322 
Line 3675 
       (JNIEnv *jEnv, jobject jThs, jint jP)       (JNIEnv *jEnv, jobject jThs, jint jP)
 { {
    CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, 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, pTypeToJType[cv->getType()]);     return DEBUG_ConvertCToJava (int, jint, iJType);
 } }
  
 JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString
Line 3346 
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 4542 
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.32  
changed lines
  Added in v.1.35.2.2
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2