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

version 1.33.2.2, 2006/03/07 18:45:59 version 1.35.2.2, 2006/05/17 20:57:39
Line 61 
Line 61 
 #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 114 
Line 115 
 /*30*/ "org/pegasus/jmpi/CIMInstanceException", /*30*/ "org/pegasus/jmpi/CIMInstanceException",
 /*31*/ "org/pegasus/jmpi/CIMObject", /*31*/ "org/pegasus/jmpi/CIMObject",
 /*32*/ "java/lang/Character", /*32*/ "java/lang/Character",
   /*33*/ "org/pegasus/jmpi/OperationContext",
   /*34*/ "java/lang/Class",
 }; };
  
 const METHOD_STRUCT instanceMethodNames[]={ const METHOD_STRUCT instanceMethodNames[]={
Line 165 
Line 168 
 /*45 CIMValueNewI            */ { /*CIMValue      */19, "<init>",          "(I)V" }, /*45 CIMValueNewI            */ { /*CIMValue      */19, "<init>",          "(I)V" },
 /*46 CIMObjectNewIZ          */ { /*CIMObject     */31, "<init>",          "(IZ)V" }, /*46 CIMObjectNewIZ          */ { /*CIMObject     */31, "<init>",          "(IZ)V" },
 /*47 CharacterNewC           */ { /*Character     */32, "<init>",          "(C)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 215 
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 1407 
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 1902 
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 2047 
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 2879 
Line 3008 
  
       delete cp;       delete cp;
  
         DEBUG_ConvertCleanup (jint, jP);
   
       return DEBUG_ConvertCToJava (CIMProperty*, jint, np);       return DEBUG_ConvertCToJava (CIMProperty*, jint, np);
    }    }
    else    else
Line 2907 
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 3092 
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 4977 
Line 5154 
    DEBUG_ConvertCleanup (jint, jCc);    DEBUG_ConvertCleanup (jint, jCc);
 } }
  
   // -------------------------------------
   // ---
   // -            CIMObject
   // ---
   // -------------------------------------
   
 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObject__1newClass JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObject__1newClass
   (JNIEnv *jEnv, jobject jThs, jobject jCc)    (JNIEnv *jEnv, jobject jThs, jint jCc)
 { {
    CIMClass *cCc = DEBUG_ConvertJavaToC (jint, CIMClass*, jCc);    CIMClass *cCc = DEBUG_ConvertJavaToC (jint, CIMClass*, jCc);
  
Line 4993 
Line 5176 
 } }
  
 JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObject__1newInstance JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObject__1newInstance
   (JNIEnv *jEnv, jobject jThs, jobject jCi)    (JNIEnv *jEnv, jobject jThs, jint jCi)
 { {
    CIMInstance *cCi = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);    CIMInstance *cCi = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);
  
Line 5017 
Line 5200 
    DEBUG_ConvertCleanup (jint, jInst);    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.33.2.2  
changed lines
  Added in v.1.35.2.2
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2