jmpiimpl.cpp

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

   CIMClass   *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
   const char *str = jEnv->GetStringUTFChars (jN, NULL);
   jlong       rv  = 0;
   Uint32      pos = cls->findQualifier (String (str));

   if (pos != PEG_NOT_FOUND)
      rv = DEBUG_ConvertCToJava (CIMQualifier*,
                                 jlong,
                                 new CIMQualifier (cls->getQualifier (pos)));

   jEnv->ReleaseStringUTFChars (jN, str);

   return rv;
}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getQualifiers
      (JNIEnv *jEnv, jobject jThs, jlong jCls, jobject jVec)
{
   JMPIjvm::cacheIDs (jEnv);

   CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);

   for (int i = 0, s = cls->getQualifierCount (); i < s; i++)
   {
      CIMQualifier *cq   = new CIMQualifier (cls->getQualifier (i));
      jlong         jCq  = DEBUG_ConvertCToJava (CIMQualifier*, jlong, cq);
      jobject       qual = jEnv->NewObject (JMPIjvm::jv.CIMQualifierClassRef,JMPIjvm::jv.CIMQualifierNewJ,jCq);

      jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,qual);
   }

   return jVec;
}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1hasQualifier
     (JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jQ)
{
   CIMClass   *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
   const char *str = jEnv->GetStringUTFChars (jQ,NULL);
   Uint32      pos = cls->findQualifier (String (str));

   jEnv->ReleaseStringUTFChars (jQ,str);

   return (jboolean)(pos != PEG_NOT_FOUND);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1addProperty
      (JNIEnv *jEnv, jobject jThs, jlong jCls, jlong jP)
{
   CIMClass    *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
   CIMProperty *p   = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jP);

   try
   {
      cls->addProperty (*p);
   }
   Catch (jEnv);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClass__1setProperties
      (JNIEnv *jEnv, jobject jThs, jlong jCls, jobject jVec)
{
   JMPIjvm::cacheIDs (jEnv);

   CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);

   for (int i = cls->getPropertyCount () - 1; i >= 0; i--)
   {
      cls->removeProperty (i);
   }
   for (Uint32 i = 0, s = jEnv->CallIntMethod (jVec, JMPIjvm::jv.VectorSize); i < s; i++)
   {
      JMPIjvm::checkException (jEnv);

      jobject      o  = jEnv->CallObjectMethod (jVec,JMPIjvm::jv.VectorElementAt, (i));
      jlong        jp = jEnv->CallLongMethod (o,JMPIjvm::jv.CIMPropertyCInst);
      CIMProperty *cp = DEBUG_ConvertJavaToC (jlong, CIMProperty*, jp);

      JMPIjvm::checkException (jEnv);

      cls->addProperty (*cp);
   }
}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperty
     (JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jN)
{
   CIMClass   *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
   const char *str = jEnv->GetStringUTFChars (jN,NULL);
   jlong       rv  = 0;
   Uint32      pos = cls->findProperty (CIMName (str));

   if (pos != PEG_NOT_FOUND)
      rv = DEBUG_ConvertCToJava (CIMProperty*,
                                 jlong,
                                 new CIMProperty (cls->getProperty (pos)));

   jEnv->ReleaseStringUTFChars (jN,str);

   return rv;
}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties
      (JNIEnv *jEnv, jobject jThs, jlong jCls, jobject jVec)
{
   JMPIjvm::cacheIDs (jEnv);

   CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);

   for (int i = 0, s = cls->getPropertyCount (); i < s; i++)
   {
      CIMProperty *cp   = new CIMProperty (cls->getProperty (i));
      jlong        jCp  = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp);
      jobject      prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewJ,jCp);

      jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,prop);
   }

   return jVec;
}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1new
      (JNIEnv *jEnv, jobject jThs, jstring jN)
{
   const char *str = jEnv->GetStringUTFChars (jN,NULL);
   CIMClass   *cls = new CIMClass (CIMName (str), CIMName ());

   jEnv->ReleaseStringUTFChars (jN,str);

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

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getSuperClass
      (JNIEnv *jEnv, jobject jThs, jlong jCls)
{
   CIMClass     *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
   const String &cn  = cls->getSuperClassName ().getString ();

   jstring str = jEnv->NewStringUTF (cn.getCString ());

   return str;
}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getKeys
      (JNIEnv *jEnv, jobject jThs, jlong jCls, jobject jVec)
{
   JMPIjvm::cacheIDs (jEnv);

   CIMClass *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);

   if (cls->hasKeys ())
   {
      Array<CIMName> keyNames;

      cls->getKeyNames (keyNames);

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

         if (pos != PEG_NOT_FOUND)
         {
            CIMProperty *cp  = new CIMProperty (cls->getProperty (pos));
            jlong        jCp = DEBUG_ConvertCToJava (CIMProperty*, jlong, cp);

            jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewJ,jCp);

            jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,prop);
         }
      }
   }

   return jVec;
}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClass__1getMethod
      (JNIEnv *jEnv, jobject jThs, jlong jCls, jstring jN)
{
   CIMClass   *cls = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
   const char *str = jEnv->GetStringUTFChars (jN,NULL);
   jlong       rv  = 0;
   Uint32      pos = cls->findMethod (String (str));

   if (pos != PEG_NOT_FOUND)
   {
      rv = DEBUG_ConvertCToJava (CIMMethod*, jlong, new CIMMethod (cls->getMethod (pos)));
   }

   jEnv->ReleaseStringUTFChars (jN,str);

   return rv;
}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1equals
      (JNIEnv *jEnv, jobject jThs, jlong jCls, jlong jClsToBeCompared)
{
   CIMClass *cls             = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCls);
   CIMClass *clsToBeCompared = DEBUG_ConvertJavaToC (jlong, CIMClass*, jClsToBeCompared);
   bool      fRc             = false;

   if (  cls
      && clsToBeCompared
      )
   {
      try
      {
         fRc = cls->identical (*clsToBeCompared);
      }
      Catch (jEnv);
   }

   return fRc;
}

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

   delete cls;

   DEBUG_ConvertCleanup (jlong, jCls);
}


// -------------------------------------
// ---
// -		CIMClient
// ---
// -------------------------------------

void checkNs (CIMObjectPath *cop, jlong jNs)
{
   if (cop->getNameSpace ().isNull ())
   {
      _nameSpace *cNs = DEBUG_ConvertJavaToC (jlong, _nameSpace*, jNs);

      cop->setNameSpace (CIMNamespaceName (cNs->nameSpace ()));
   }
}

static int normalizeNs (String &ns, String &nsBase, String &lastNsComp)
{
   Uint32 n = ns.size ();

   if (ns[n-1] == '/')
   {
      if (n >= 2)
         ns = ns.subString (0, n-2);
   }

   lastNsComp = ns;
   nsBase     = "root";

   n = ns.reverseFind ('/');

   if (n != PEG_NOT_FOUND)
   {
      lastNsComp = ns.subString (n+1);
      nsBase     = ns.subString (0, n);
   }

   return 0;
}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1newNaUnPw
  (JNIEnv *jEnv, jobject jThs, jlong jNs, jstring jUn, jstring jPw)
{
   _nameSpace *cNs = DEBUG_ConvertJavaToC (jlong, _nameSpace*, jNs);
   const char *un  = jEnv->GetStringUTFChars (jUn, NULL);
   const char *pw  = jEnv->GetStringUTFChars (jPw, NULL);
   jlong       jCc = 0;

   try {
      CIMClient *cc = new CIMClient ();

      cc->connect (cNs->hostName (), cNs->port (), un, pw);

      jCc = DEBUG_ConvertCToJava (CIMClient*, jlong, cc);
   }
   Catch (jEnv);

   jEnv->ReleaseStringUTFChars (jUn, un);
   jEnv->ReleaseStringUTFChars (jPw, pw);

   return jCc;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1disconnect
  (JNIEnv *jEnv, jobject jThs, jlong jCc)
{
   CIMClient *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);

   try {
      cCc->disconnect ();
   }
   Catch (jEnv);
}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1getClass
  (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jboolean lo,
         jboolean iq, jboolean ic, jobjectArray jPl)
{
   CIMClient       *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
   CIMObjectPath   *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
   CIMPropertyList  pl = getList (jEnv, jPl);

   if (  cCc
      && cop
      )
   {
      try {
         checkNs (cop, jNs);

         CIMClass      cls    = cCc->getClass (cop->getNameSpace (),
                                               cop->getClassName (),
                                               (Boolean)lo,
                                               (Boolean)iq,
                                               (Boolean)ic,
                                               pl);
         CIMObjectPath copNew = cls.getPath ();

         copNew.setNameSpace (cop->getNameSpace ());
         cls.setPath (copNew);

         return DEBUG_ConvertCToJava (CIMClass*, jlong, new CIMClass (cls));
      }
      Catch (jEnv);
   }

   return 0;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteClass
  (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop)
{
   CIMClient     *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);

   try {
      checkNs (cop, jNs);

      cCc->deleteClass (cop->getNameSpace (),
                        cop->getClassName ());
   }
   Catch (jEnv);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1createClass
  (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jlong jCl)
{
   CIMClient     *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
   CIMClass      *cl  = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCl);

   try {
      cCc->createClass (cop->getNameSpace (), *cl);
   }
   Catch (jEnv);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setClass
  (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jlong jCl)
{
   CIMClient     *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
   CIMClass      *cl  = DEBUG_ConvertJavaToC (jlong, CIMClass*, jCl);

   try {
     checkNs (cop, jNs);

     cCc->modifyClass (cop->getNameSpace (), *cl);
   }
   Catch (jEnv);
}

JNIEXPORT jlong JNICALL Java_org_pegasus_jmpi_CIMClient__1getInstance
  (JNIEnv *jEnv, jobject jThs, jlong jCc, jlong jNs, jlong jCop, jboolean lo,
         jboolean iq, jboolean ic, jobjectArray jPl)
{
   CIMClient        *cCc = DEBUG_ConvertJavaToC (jlong, CIMClient*, jCc);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jlong, CIMObjectPath*, jCop);
   CIMPropertyList   pl  = getList (jEnv, jPl);

   try {
      checkNs (cop, jNs);

      CIMInstance inst = cCc->getInstance (cop->getNameSpace (),
                                           *cop,
                                           (Boolean)lo,
                                           (Boolean)iq,
                                           (Boolean)ic,
                                           pl);

      inst.setPath (*cop);

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

   return 0;