jmpiimpl.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

                                   0,
                                   (jsize)len,
                                   (jbyte *)s);
        if (!(*env).ExceptionOccurred ())
        {
            str = (jstring)(*env).NewObject (cls, mid, ary);
        }
        (*env).DeleteLocalRef (ary);

        return str;
    }
    return 0;
}

/**************************************************************************
 * name         - NewPlatformStringArray
 * description  - Returns a new array of Java string objects for the specified
 *                array of platform strings.
 * parameters   - env
 *                strv      Platform encoded string array
 *                strc      Number of strings in strv
 * returns      - Java string array object pointer
 **************************************************************************/
jobjectArray JMPIjvm::NewPlatformStringArray (JNIEnv *env, char **strv, int strc)
{
    jarray cls;
    jarray ary;
    int i;

    NULL_CHECK0(cls = (jarray)(*env).FindClass("java/lang/String"));
    NULL_CHECK0(ary = (*env).NewObjectArray(strc, (jclass)cls, 0));
    for(i = 0; i < strc; i++)
    {
        jstring str = NewPlatformString (env, *strv++);

        NULL_CHECK0(str);

        (*env).SetObjectArrayElement ((jobjectArray)ary, i, str);
        (*env).DeleteLocalRef (str);
    }

    return (jobjectArray)ary;
}

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" {

void throwCimException (JNIEnv *jEnv, CIMException &e)
{
      JMPIjvm::cacheIDs(jEnv);
      jobject ev = jEnv->NewObject(JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewI,(jint)e.getCode());
      jEnv->Throw((jthrowable)ev);
}

void throwFailedException (JNIEnv *jEnv)
{
      JMPIjvm::cacheIDs(jEnv);
      jobject ev = jEnv->NewObject(JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewI,1);
      jEnv->Throw((jthrowable)ev);
}

void throwNotSupportedException (JNIEnv *jEnv)
{
      JMPIjvm::cacheIDs(jEnv);
      jobject ev = jEnv->NewObject(JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewI,7);
      jEnv->Throw((jthrowable)ev);
}


// -------------------------------------
// ---
// -		CIMArgument
// ---
// -------------------------------------

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1new
      (JNIEnv *jEnv, jobject jThs)
{
   CIMParamValue *p = new CIMParamValue (String::EMPTY,CIMValue ());

   return DEBUG_ConvertCToJava (CIMParamValue*, jlong, p);
}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1newS
      (JNIEnv *jEnv, jobject jThs, jstring jN)
{
   const char    *str = jEnv->GetStringUTFChars (jN, NULL);
   CIMParamValue *p   = new CIMParamValue (str, CIMValue ());

   jEnv->ReleaseStringUTFChars (jN, str);

   return DEBUG_ConvertCToJava (CIMParamValue*, jlong, p);
}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1newSV
      (JNIEnv *jEnv, jobject jThs, jstring jN, jlong jV)
{
   const char    *str = jEnv->GetStringUTFChars (jN, NULL);
   CIMValue      *cv  = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);
   CIMParamValue *p   = 0;

   if (  str
      && cv
      )
   {
      p = new CIMParamValue (str, *cv);
   }

   jEnv->ReleaseStringUTFChars (jN, str);

   return DEBUG_ConvertCToJava (CIMParamValue*, jlong, p);
}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1getType
      (JNIEnv *jEnv, jobject jThs, jlong jP)
{
   CIMParamValue *cp       = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);
   const CIMValue cv       = cp->getValue ();
   String         ref;
   bool           fSuccess = false;
   int            iJType   = 0;
   _dataType     *type     = 0;

   iJType = _dataType::convertCTypeToJavaType (cv.getType (), &fSuccess);

   if (fSuccess)
   {
      type = new _dataType (iJType,
                            cv.getArraySize (),
                            false,
                            false,
                            cv.isArray (),
                            ref,
                            true);
   }

   return DEBUG_ConvertCToJava (_dataType*, jlong, type);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setValue
      (JNIEnv *jEnv, jobject jThs, jlong jP,jlong jV)
{
   CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);
   CIMValue      *cv = DEBUG_ConvertJavaToC (jlong, CIMValue*, jV);

   cp->setValue (*cv);
}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMArgument__1getValue
      (JNIEnv *jEnv, jobject jThs, jlong jP)
{
   CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);
   CIMValue      *cv = new CIMValue (cp->getValue ());

   return DEBUG_ConvertCToJava (CIMValue*, jlong, cv);
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMArgument__1getName
      (JNIEnv *jEnv, jobject jThs, jlong jP)
{
   CIMParamValue *cp  = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);
   const String  &n   = cp->getParameterName ();
   jstring        str = jEnv->NewStringUTF (n.getCString ());

   return str;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1setName
      (JNIEnv *jEnv, jobject jThs, jlong jP, jstring jN)
{
   CIMParamValue *cp  = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);
   const char    *str = jEnv->GetStringUTFChars (jN, NULL);
   String         n (str);

   cp->setParameterName (n);

   jEnv->ReleaseStringUTFChars (jN, str);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMArgument__1finalize
      (JNIEnv *jEnv, jobject jThs, jlong jP)
{
   CIMParamValue *cp = DEBUG_ConvertJavaToC (jlong, CIMParamValue*, jP);

   delete cp;

   DEBUG_ConvertCleanup (jlong, jP);
}


// -------------------------------------
// ---
// -		CIMClass
// ---
// -------------------------------------

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1newInstance
  (JNIEnv *jEnv, jobject jThs, jlong jCls)
{
   CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);

   if (cls)
   {
      try
      {
         CIMInstance   *ci     = new CIMInstance (cls->getClassName ());
         CIMObjectPath  copNew = ci->getPath ();

         copNew.setNameSpace (cls->getPath ().getNameSpace ());
         ci->setPath (copNew);

         for (int i = 0, m = cls->getQualifierCount (); i < m; i++)
         {
            try
            {
               ci->addQualifier (cls->getQualifier (i).clone ());
            }
            catch (Exception e)
            {
            }
         }
         for (int i = 0, m = cls->getPropertyCount (); i < m; i++)
         {
            CIMProperty cp = cls->getProperty (i);

            ci->addProperty (cp.clone ());

            for (int j = 0, s = cp.getQualifierCount (); j < s; j++)
            {
               try
               {
                  ci->getProperty (i).addQualifier (cp.getQualifier (j));
               }
               catch (Exception e)
               {
               }
            }
         }

         return DEBUG_ConvertCToJava (CIMInstance*, jlong, ci);
      }
      Catch (jEnv);
   }

   return 0;
}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1filterProperties
      (JNIEnv *jEnv, jobject jThs, jlong jInst, jobjectArray jPl, jboolean iq, jboolean ic, jboolean lo)
{
   CIMClass *cc   = DEBUG_ConvertJavaToC (jlong, CIMClass*, jInst);
   CIMClass *cf   = 0;
   CIMName   clsn = cc->getClassName ();

   if (lo)
   {
      cf = new CIMClass (cc->clone ());

      CIMName clsn = cc->getClassName ();

      for (int i = cf->getPropertyCount () - 1; i>= 0; i--)
      {
         if (cf->getProperty (i).getClassOrigin () == clsn)
            cf->removeProperty (i);
      }

      return DEBUG_ConvertCToJava (CIMClass*, jlong, cf);
   }
   else if (jPl)
   {
      CIMPropertyList pl = getList (jEnv,jPl);
      Array<CIMName>  n  = pl.getPropertyNameArray ();

      cf = new CIMClass (clsn, cc->getSuperClassName ());

      for (int i = 0, s = n.size (); i < s; i++)
      {
         Uint32 pos = cc->findProperty (n[i]);

         if (pos != PEG_NOT_FOUND)
         {
            if (iq)
            {
               CIMProperty cp = cc->getProperty (pos).clone ();

               if (!ic)
                  cp.setClassOrigin (CIMName ());

               cf->addProperty (cp);
            }
            else
            {
               CIMProperty cp = cc->getProperty (pos);
               CIMName     co;

               if (ic)
                  co = cp.getClassOrigin ();

               CIMProperty np (cp.getName (),
                              cp.getValue (),
                              cp.getArraySize (),
                              cp.getReferenceClassName (),
                              co,
                              cp.getPropagated ());

               cf->addProperty (np);
            }
         }
      }
      if (iq)
      {
         for (Uint32 i = 0, s = cc->getQualifierCount (); i < s; i++)
         {
            cf->addQualifier (cc->getQualifier (i));
         }
      }
   }
   else if (iq)
   {
      cf = new CIMClass (cc->clone ());

      if (ic)
         return DEBUG_ConvertCToJava (CIMClass*, jlong, cf);

      for (int i = cf->getPropertyCount () - 1; i >= 0; i--)
      {
         CIMProperty cp = cf->getProperty (i);

         cp.setClassOrigin (CIMName ());
         cf->removeProperty (i);
         cf->addProperty (cp);
      }
   }
   else
   {
      cf = new CIMClass (clsn, cc->getSuperClassName ());

      for (int i = cc->getPropertyCount () - 1; i >= 0; i--)
      {
         CIMProperty cp = cc->getProperty (i);
         CIMName     co;

         if (ic)
            co = cp.getClassOrigin ();

         CIMProperty np (cp.getName (),
                        cp.getValue (),
                        cp.getArraySize (),
                        cp.getReferenceClassName (),
                        co,
                        cp.getPropagated ());

         cf->addProperty (np);
      }
   }

   return DEBUG_ConvertCToJava (CIMClass*, jlong, cf);
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getName
   (JNIEnv *jEnv, jobject jThs, jlong jCls)
{
   CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);

   try {
      const String &cn = cls->getClassName ().getString ();
      jstring str = jEnv->NewStringUTF (cn.getCString ());

      return str;
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifier
   (JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jN)
{