//%2006////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation, The Open Group.
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// 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
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//==============================================================================
//
// Author:      Adrian Schuur, schuur@de.ibm.com
//
// Modified By: Adrian Dutta
//              Andy Viciu
//              Magda Vacarelu
//              David Dillard, VERITAS Software Corp.
//                  (david.dillard@veritas.com)
//              Mark Hamzy,    hamzy@us.ibm.com
//
//%/////////////////////////////////////////////////////////////////////////////
#include "JMPIImpl.h"

#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)
#include <Pegasus/Common/DynamicLibrary.h>
#else
#include <dlfcn.h>
#endif
#include <iostream>
#include <sstream>

#include <Pegasus/Common/Config.h>
#include <Pegasus/Common/System.h>
#include <Pegasus/Common/CIMClass.h>
#include <Pegasus/Common/CIMInstance.h>
#include <Pegasus/Common/CIMObjectPath.h>
#include <Pegasus/Common/CIMProperty.h>
#include <Pegasus/Common/OperationContext.h>
#include <Pegasus/Provider/CIMOMHandle.h>
#include <Pegasus/Client/CIMClient.h>
#include <Pegasus/ProviderManager2/JMPI/JMPIProviderManager.h>
#include <Pegasus/WQL/WQLSelectStatement.h>
#include <Pegasus/WQL/WQLParser.h>
#define CALL_SIGN_WQL "WQL"

PEGASUS_USING_STD;
PEGASUS_NAMESPACE_BEGIN

JavaVM *JMPIjvm::jvm=NULL;
JvmVector JMPIjvm::jv;
int JMPIjvm::trace=0;

#ifdef PEGASUS_DEBUG
#define DDD(x) if (JMPIjvm::trace) x;
#else
#define DDD(x)
#endif

#include "Convert.h"

JMPIjvm::ClassTable  JMPIjvm::_classTable;
JMPIjvm::ObjectTable JMPIjvm::_objectTable;

const char* classNames[]={
/*00*/ "java/util/Vector" ,
/*01*/ "java/lang/Boolean",
/*02*/ "java/lang/Byte",
/*03*/ "java/lang/Short",
/*04*/ "java/lang/Integer",
/*05*/ "java/lang/Long",
/*06*/ "java/lang/Float",
/*07*/ "java/lang/Double",
/*08*/ "org/pegasus/jmpi/UnsignedInt8",
/*09*/ "org/pegasus/jmpi/UnsignedInt16",
/*10*/ "org/pegasus/jmpi/UnsignedInt32",
/*11*/ "org/pegasus/jmpi/UnsignedInt64",
/*12*/ "org/pegasus/jmpi/CIMObjectPath",
/*13*/ "org/pegasus/jmpi/CIMException",
/*14*/ "java/math/BigInteger",
/*15*/ "org/pegasus/jmpi/CIMProperty",
/*16*/ "org/pegasus/jmpi/CIMOMHandle",
/*17*/ "org/pegasus/jmpi/CIMClass",
/*18*/ "org/pegasus/jmpi/CIMInstance",
/*19*/ "org/pegasus/jmpi/CIMValue",
/*20*/ "java/lang/Object",
/*21*/ "java/lang/Throwable",
/*22*/ "java/lang/String",
/*23*/ "org/pegasus/jmpi/JarClassLoader",
/*24*/ "org/pegasus/jmpi/CIMDateTime",
/*25*/ "org/pegasus/jmpi/SelectExp",
/*26*/ "org/pegasus/jmpi/CIMQualifier",
/*27*/ "org/pegasus/jmpi/CIMQualifierType",
/*28*/ "org/pegasus/jmpi/CIMFlavor",
/*29*/ "org/pegasus/jmpi/CIMArgument",
/*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[]={
/*00 VectorNew                   */ { /*Vector           */ 0, "<init>",          "()V" },
/*01 BooleanNewZ                 */ { /*Boolean          */ 1, "<init>",          "(Z)V" },
/*02 ByteNewB                    */ { /*Byte             */ 2, "<init>",          "(B)V" },
/*03 ShortNewS                   */ { /*Short            */ 3, "<init>",          "(S)V" },
/*04 IntegerNewI                 */ { /*Integer          */ 4, "<init>",          "(I)V" },
/*05 LongNewJ                    */ { /*Long             */ 5, "<init>",          "(J)V" },
/*06 FloatNewF                   */ { /*Float            */ 6, "<init>",          "(F)V" },
/*07 DoubleNewD                  */ { /*Double           */ 7, "<init>",          "(D)V" },
/*08 UnsignedInt8NewS            */ { /*UnsignedInt8     */ 8, "<init>",          "(S)V" },
/*09 UnsignedInt16NewI           */ { /*UnsignedInt16    */ 9, "<init>",          "(I)V" },
/*10 UnsignedInt32NewJ           */ { /*UnsignedInt32    */10, "<init>",          "(J)V" },
/*11 UnsignedInt64NewBi          */ { /*UnsignedInt64    */11, "<init>",          "(Ljava/math/BigInteger;)V" },
/*12 CIMObjectPathNewI           */ { /*CIMObjectPath    */12, "<init>",          "(I)V" },
/*13 CIMExceptionNewSt           */ { /*CIMException     */13, "<init>",          "(Ljava/lang/String;)V" },
/*14 CIMPropertyNewI             */ { /*CIMProperty      */15, "<init>",          "(I)V" },
/*15 VectorAddElement            */ { /*Vector           */ 0, "addElement",      "(Ljava/lang/Object;)V" },
/*16 VectorElementAt             */ { /*Vector           */ 0, "elementAt",       "(I)Ljava/lang/Object;" },
/*17 CIMOMHandleNewISt           */ { /*CIMOMHandle      */16, "<init>",          "(ILjava/lang/String;)V" },
/*18 CIMExceptionNewI            */ { /*CIMException     */13, "<init>",          "(I)V" },
/*19 CIMClassNewI                */ { /*CIMClass         */17, "<init>",          "(I)V" },
/*20 CIMInstanceNewI             */ { /*CIMInstance      */18, "<init>",          "(I)V" },
/*21 CIMObjectPathCInst          */ { /*CIMObjectPath    */12, "cInst",           "()I" },
/*22 CIMInstanceCInst            */ { /*CIMInstance      */18, "cInst",           "()I" },
/*23 CIMClassCInst               */ { /*CIMClass         */17, "cInst",           "()I" },
/*24 ObjectToString              */ { /*Object           */20, "toString",        "()Ljava/lang/String;" },
/*25 ThrowableGetMessage         */ { /*Throwable        */21, "getMessage",      "()Ljava/lang/String;" },
/*26 CIMExceptionGetID           */ { /*CIMException     */13, "getID",           "()Ljava/lang/String;" },
/*27 VectorSize                  */ { /*Vector           */ 0, "size",            "()I" },
/*28 CIMPropertyCInst            */ { /*CIMProperty      */15, "cInst",           "()I" },
/*29 CIMOMHandleGetClass         */ { /*CIMOMHandle      */16, "getClass",        "(Lorg/pegasus/jmpi/CIMObjectPath;Z)Lorg/pegasus/jmpi/CIMClass;" },
/*30 VectorRemoveElementAt       */ { /*Vector           */ 0, "removeElementAt", "(I)V" },
/*31 CIMValueCInst               */ { /*CIMValue         */19, "cInst",           "()I" },
/*32 CIMExceptionNewISt          */ { /*CIMException     */13, "<init>",          "(ILjava/lang/String;)V" },
/*33 CIMExceptionGetCode         */ { /*CIMException     */13, "getCode",         "()I" },
/*34 CIMDateTimeNewI             */ { /*CIMDateTime      */24, "<init>",          "(I)V" },
/*35 SelectExpNewI               */ { /*SelectExp        */25, "<init>",          "(I)V" },
/*36 CIMQualifierNewI            */ { /*CIMQualifier     */26, "<init>",          "(I)V" },
/*37 CIMFlavorNewI               */ { /*CIMFlavor        */28, "<init>",          "(I)V" },
/*38 CIMFlavorGetFlavor          */ { /*CIMFlavor        */28, "getFlavor",       "()I" },
/*39 CIMArgumentCInst            */ { /*CIMArgument      */29, "cInst",           "()I" },
/*40 CIMArgumentNewI             */ { /*CIMArgument      */29, "<init>",          "(I)V" },
/*41 CIMExceptionNew             */ { /*CIMException     */13, "<init>",          "()V" },
/*42 CIMExceptionNewStOb         */ { /*CIMException     */13, "<init>",          "(Ljava/lang/String;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" },
/*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[]={
/*00*/ { 14, "valueOf",         "(J)Ljava/math/BigInteger;" },
/*01*/ { 23, "load",            "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Class;" },
};

static int methodInitDone=0;

jclass    classRefs[sizeof(classNames)/sizeof(classNames[0])];
jmethodID instanceMethodIDs[sizeof(instanceMethodNames)/sizeof(instanceMethodNames[0])];
jmethodID staticMethodIDs[sizeof(staticMethodNames)/sizeof(staticMethodNames[0])];

jclass JMPIjvm::getGlobalClassRef(JNIEnv *env, const char* name)
{
  jclass localRefCls = env->FindClass(name);

  if (localRefCls == NULL)
     return JNI_FALSE;

  jclass globalRefCls = (jclass) env->NewGlobalRef(localRefCls);

#if 0
  jmethodID   jmidToString   = env->GetMethodID(globalRefCls, "toString", "()Ljava/lang/String;");
  jstring     jstringResult  = (jstring)env->CallObjectMethod(globalRefCls, jmidToString);
  const char *pszResult      = env->GetStringUTFChars(jstringResult, 0);

  DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getGlobalClassRef: globalRefCls = "<<PEGASUS_STD(hex)<<(int)globalRefCls<<PEGASUS_STD(dec)<<", name = "<<name<<", pszResult = "<<pszResult<<PEGASUS_STD(endl));

  env->ReleaseStringUTFChars (jstringResult, pszResult);
#else
  DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getGlobalClassRef: globalRefCls = "<<PEGASUS_STD(hex)<<(int)globalRefCls<<PEGASUS_STD(dec)<<", name = "<<name<<PEGASUS_STD(endl));
#endif

  env->DeleteLocalRef(localRefCls);

  return globalRefCls;
}

JMPIjvm::JMPIjvm()
{
   initJVM ();
}

JMPIjvm::~JMPIjvm()
{
}

int JMPIjvm::cacheIDs(JNIEnv *env)
{
   if (methodInitDone == 1)
      return JNI_TRUE;
   if (methodInitDone == -1)
      return JNI_FALSE;

   DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): enter"<<PEGASUS_STD(endl));

   methodInitDone = -1;

   for (unsigned i = 0; i<(sizeof(classNames)/sizeof(classNames[0])); i++)
   {
//////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<classNames[i]<<PEGASUS_STD(endl));
      if ((classRefs[i] = getGlobalClassRef(env,classNames[i])) == NULL)
      {
         DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error: Count not find global class ref for "<<classNames[i]<<PEGASUS_STD(endl));

         return JNI_FALSE;
      }
   }

   for (unsigned j = 0; j<(sizeof(instanceMethodNames)/sizeof(instanceMethodNames[0])); j++)
   {
//////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<j<<": "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<": "<<instanceMethodNames[j].signature<<PEGASUS_STD(endl));
      if ((instanceMethodIDs[j] = env->GetMethodID(classRefs[instanceMethodNames[j].clsIndex],
                                                 instanceMethodNames[j].methodName,
                                                 instanceMethodNames[j].signature)) == NULL)
      {
         DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error could not get method id for "<<classNames[instanceMethodNames[j].clsIndex]<<": "<<instanceMethodNames[j].methodName<<PEGASUS_STD(endl));
         return 0;
      }
   }

   for (unsigned k = 0; k<(sizeof(staticMethodNames)/sizeof(staticMethodNames[0])); k++)
   {
//////DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Trying "<<k<<": "<<classNames[staticMethodNames[k].clsIndex]<<": "<<staticMethodNames[k].methodName<<": "<<staticMethodNames[k].signature<<PEGASUS_STD(endl));
      if ((staticMethodIDs[k] = env->GetStaticMethodID(classRefs[staticMethodNames[k].clsIndex],
                                                     staticMethodNames[k].methodName,
                                                     staticMethodNames[k].signature)) == NULL)
      {
         DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): Error could not get method id for "<<classNames[staticMethodNames[k].clsIndex]<<": "<<staticMethodNames[k].methodName<<PEGASUS_STD(endl));
         return 0;
      }
   }

   DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::cacheIDs(): exit"<<PEGASUS_STD(endl));

   jv.env = env;
   jv.classRefs = classRefs;
   jv.instMethodIDs = instanceMethodIDs;
   jv.staticMethodIDs = staticMethodIDs;
   jv.instanceMethodNames = instanceMethodNames;

   methodInitDone = 1;

   return JNI_TRUE;
}

static void throwCIMException(JNIEnv *env,char *e)
{
   JMPIjvm::cacheIDs(env);

   env->ThrowNew(JMPIjvm::jv.CIMExceptionClassRef,e);
}

int JMPIjvm::destroyJVM()
{
   DDD(PEGASUS_STD(cerr)<<"--- JPIjvm::destroyJVM()"<<PEGASUS_STD(endl));

#ifdef JAVA_DESTROY_VM_WORKS
   if (jvm!= NULL)
   {
      JvmVector *jv;

      attachThread(&jv);

      jvm->DestroyJavaVM();

      jvm = NULL;

      return 0;
   }
#endif

   return -1;
}

Mutex JMPIjvm::_initMutex;

int JMPIjvm::initJVM ()
{
   AutoMutex lock (_initMutex);

   if (jvm != NULL)
   {
      return 0;
   }

   JavaVMInitArgs vm_args;
   jint res;
   char *envstring;
   JNIEnv *env;
   JavaVMOption *poptions = 0;
   int maxoption = 0;
   typedef struct _JVMOptions {
      const char *pszEnvName;
      const char *pszPrefix;
      bool        fSplit;
   } JVMOPTIONS;
   Array<std::string> JNIoptions;
   static JVMOPTIONS aEnvOptions[] = {
      { "CLASSPATH",                           "-Djava.class.path=", false },
      { "PEGASUS_JMPI_MAX_HEAP",               "-Xmx"              , false },
      { "PEGASUS_JMPI_INITIAL_HEAP",           "-Xms"              , false },
      { "PEGASUS_JMPI_JAVA_THREAD_STACK_SIZE", "-Xss"              , false },
      { "PEGASUS_JMPI_VERBOSE",                "-verbose:"         , true  }
   };
   std::ostringstream oss;

#ifdef PEGASUS_DEBUG
   if (getenv("PEGASUS_JMPI_TRACE"))
      JMPIjvm::trace = 1;
   else
      JMPIjvm::trace = 0;
#else
   JMPIjvm::trace = 0;
#endif

   DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM()" << PEGASUS_STD(endl));

   jv.initRc = 0;

   envstring = getenv("CLASSPATH");
   if (envstring == NULL)
   {
      jv.initRc = 1;

      DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): No CLASSPATH environment variable found" << PEGASUS_STD(endl));

#ifdef PEGASUS_PLATFORM_ZOS_ZSERIES_IBM
      throw PEGASUS_CIM_EXCEPTION_L(
                 CIM_ERR_FAILED,
                 MessageLoaderParms(
                     "ProviderManager2.JMPI.GET_CLASSPATH_FAILED.PEGASUS_OS_ZOS",
                     "Could not get CLASSPATH from environment."
                     " Either CLASSPATH is longer than 255 characters"
                     " or not set at all.")
                 );
#else
      throw PEGASUS_CIM_EXCEPTION_L(
                 CIM_ERR_FAILED,
                 MessageLoaderParms(
                     "ProviderManager2.JMPI.GET_CLASSPATH_FAILED.STANDARD",
                     "Could not get CLASSPATH from environment.")
                 );
#endif
      return -1;
   }

///JNIoptions.append ("-Djava.compiler = NONE");
///maxoption++;

   for (Uint32 i = 0; i < (int)(sizeof (aEnvOptions)/sizeof (aEnvOptions[0])); i++)
   {
      JVMOPTIONS *pEnvOption = &aEnvOptions[i];

      envstring = getenv (pEnvOption->pszEnvName);
      if (envstring)
      {
         if (pEnvOption->fSplit)
         {
            bool              fCommaFound  = true;
            string            stringValues = envstring;
            string::size_type posStart     = 0;
            string::size_type posEnd       = stringValues.length () - 1;

            while (fCommaFound)
            {
               string            stringValue;
               string::size_type posComma    = stringValues.find (',', posStart);

               if (posComma != string::npos)
               {
                  fCommaFound = true;
                  stringValue = stringValues.substr (posStart, posComma);
                  posStart    = posComma + 1;
               }
               else
               {
                  fCommaFound = false;
                  stringValue = stringValues.substr (posStart, posEnd - posStart + 1);
               }

               DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): fCommaFound = " << fCommaFound << ", posStart = " << posStart << ", posComma = " << posComma << ", posEnd = " << posEnd << "" << PEGASUS_STD(endl));

               maxoption++;

               oss.str ("");
               oss << pEnvOption->pszPrefix << stringValue;

               JNIoptions.append (oss.str ());

               DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): " << pEnvOption->pszEnvName << " found!  Specifying \"" << oss.str () << "\"" << PEGASUS_STD(endl));
            }
         }
         else
         {
            maxoption++;

            oss.str ("");
            oss << pEnvOption->pszPrefix << envstring;

            JNIoptions.append (oss.str ());

            DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): " << pEnvOption->pszEnvName << " found!  Specifying \"" << oss.str () << "\"" << PEGASUS_STD(endl));
         }
      }
   }

   poptions = (JavaVMOption *)calloc (maxoption, sizeof (JavaVMOption));
   if (!poptions)
   {
      jv.initRc = 1;

      DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): Could not allocate " << maxoption << " structures of size " << sizeof (JavaVMOption) << PEGASUS_STD(endl));

      return -1;
   }

   for (Uint32 i = 0; i < JNIoptions.size(); i++)
   {
      poptions[i].optionString = (char *)JNIoptions[i].c_str ();

      DDD(PEGASUS_STD(cout) << "--- JMPIjvm::initJVM(): Setting option " << i << " to \"" << poptions[i].optionString << "\"" << PEGASUS_STD(endl));
   }

   vm_args.version = JNI_VERSION_1_2;
   vm_args.options = poptions;
   vm_args.nOptions = maxoption;
   vm_args.ignoreUnrecognized = JNI_TRUE;

   res = JNI_CreateJavaVM(&jvm,(void**)&env,&vm_args);

   if (poptions)
   {
      free (poptions);
   }

   if (res!= 0)
   {
      jv.initRc = 1;

      DDD(PEGASUS_STD(cerr) << "--- JMPIjvm::initJVM(): Can not create Java VM"<<PEGASUS_STD(endl));

      return -1;
   }

   cacheIDs(env);

   if (env->ExceptionOccurred())
   {
      jv.initRc = 1;

      env->ExceptionDescribe();

#ifdef JAVA_DESTROY_VM_WORKS

      JvmVector *jv = NULL;

      attachThread (&jv);

      jvm->DestroyJavaVM ();

      jvm = NULL;
#endif

      return -1;
   }

   jv.initRc = 1;
   jv.jvm = jvm;

   return res;
}

JNIEnv* JMPIjvm::attachThread(JvmVector **jvp)
{
   JNIEnv* env = NULL;
   int rc;

   if (jvm == NULL)
   {
      rc = initJVM ();

      if ((jvm == NULL) || (rc != 0))
         return NULL;
   }

   jvm->AttachCurrentThread ((void**)&env,NULL);

   *jvp = &jv;

   return env;
}

void JMPIjvm::detachThread()
{
   jvm->DetachCurrentThread();
}

jobject JMPIjvm::getProvider(JNIEnv *env, String jar, String cln,
     const char *cn, jclass *cls)
{
   jobject gProv = NULL;
   jclass scls = NULL;

   DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: jar = "<<jar<<", cln = "<<cln<<", cn = "<<cn<<", cls = "<<cls<<PEGASUS_STD(endl));

   _objectTable.lookup(cln,gProv);
   _classTable.lookup(cln,scls);
   DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(int)gProv<<", scls = "<<(int)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

   if (gProv)
   {
      *cls = scls;
      return gProv;
   }

   /*
   DDD(PEGASUS_STD(cout)<<"--- jar: "<<jar<<PEGASUS_STD(endl));
   DDD(PEGASUS_STD(cout)<<"--- cln: "<<cln<<PEGASUS_STD(endl));

   jstring jjar = env->NewStringUTF((const char*)jar.getCString());
   jstring jcln = env->NewStringUTF((const char*)cln.getCString());

   jclass jcls = (jclass)env->CallStaticObjectMethod (JMPIjvm::jv.JarClassLoaderRef,
                                                      jv.JarClassLoaderLoad,
                                                      jjar,
                                                      jcln);
   if (env->ExceptionCheck())
   {
      env->ExceptionDescribe();
      PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<cn<<PEGASUS_STD(endl);
////////return NULL;
   }
*/

   scls = getGlobalClassRef(env,(const char*)cln.getCString());
   if (env->ExceptionCheck())
   {
      DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::getProvider: Provider "<<cn<<" not found"<<PEGASUS_STD(endl));
      DDD(env->ExceptionDescribe());

      return NULL;
   }
   *cls = scls;

   if (scls)
   {
      DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: scls = "<<PEGASUS_STD(hex)<<(int)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
      _classTable.insert(cln,scls);
   }

   jmethodID id = env->GetMethodID(*cls,"<init>","()V");
   jobject lProv = env->NewObject(*cls,id);
   gProv = (jobject)env->NewGlobalRef(lProv);
   if (env->ExceptionCheck())
   {
      DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<cn<<PEGASUS_STD(endl));
      return NULL;
   }

   if (gProv)
   {
      DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(int)gProv<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
      _objectTable.insert(cln,gProv);
   }

   return gProv;
}

jobject JMPIjvm::getProvider(JNIEnv *env, const char *cn, jclass *cls)
{
   String cln = cn;
   jobject gProv = NULL;
   jclass scls = NULL;

   DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: cn = "<<cn<<", cls = "<<cls<<PEGASUS_STD(endl));

   _objectTable.lookup(cln,gProv);
   _classTable.lookup(cln,scls);
   DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(int)gProv<<", scls = "<<(int)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));

   if (gProv)
   {
      *cls = scls;
      return gProv;
   }

   scls = getGlobalClassRef(env,cn);
   if (env->ExceptionCheck())
   {
      DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::getProvider: Provider "<<cn<<" not found"<<PEGASUS_STD(endl));
      DDD(env->ExceptionDescribe());

      return NULL;
   }
   *cls = scls;

   if (scls)
   {
      DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: scls = "<<PEGASUS_STD(hex)<<(int)scls<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
      _classTable.insert(cln,scls);
   }

   jmethodID id = env->GetMethodID(*cls,"<init>","()V");
   jobject lProv = env->NewObject(*cls,id);
   gProv = (jobject)env->NewGlobalRef(lProv);
   if (env->ExceptionCheck())
   {
      DDD(PEGASUS_STD(cerr)<<"--- Unable to instantiate provider "<<cn<<PEGASUS_STD(endl));
      return NULL;
   }

   if (gProv)
   {
      DDD(PEGASUS_STD(cout)<<"--- JMPIjvm::getProvider: gProv = "<<PEGASUS_STD(hex)<<(int)gProv<<PEGASUS_STD(dec)<<PEGASUS_STD(endl));
      _objectTable.insert(cln,gProv);
   }

   return gProv;
}

void JMPIjvm::checkException(JNIEnv *env)
{
   if (env->ExceptionCheck ())
   {
      jstring     jMsg = NULL,
                  jId  = NULL;
      int         code;
      const char *cp;
      String      msg  = String::EMPTY,
                  id   = String::EMPTY;
      jthrowable  err  = env->ExceptionOccurred();

      DDD(env->ExceptionDescribe());

      if (env->IsInstanceOf (err, JMPIjvm::jv.CIMExceptionClassRef))
      {
         env->ExceptionClear ();
         if (err)
         {
            jMsg = (jstring)env->CallObjectMethod (err, JMPIjvm::jv.ThrowableGetMessage);
            code = (int)env->CallIntMethod (err, JMPIjvm::jv.CIMExceptionGetCode);
            jId  = (jstring)env->CallObjectMethod (err, JMPIjvm::jv.CIMExceptionGetID);

            if (jId)
            {
               cp = env->GetStringUTFChars (jId, NULL);
               id = String (cp);
               env->ReleaseStringUTFChars (jId, cp);
            }

            if (jMsg)
            {
               cp  = env->GetStringUTFChars (jMsg, NULL);
               msg = String (cp);
               env->ReleaseStringUTFChars (jMsg, cp);
            }

            DDD(PEGASUS_STD(cerr)<<"--- throwing Pegasus exception: "<<code<<" "<<id<<" ("<<msg<<")"<<PEGASUS_STD(endl));

            throw CIMException ((CIMStatusCode)code, id+" ("+msg+")");
         }
      }
      else
      {
         DDD(PEGASUS_STD(cerr)<<"--- JMPIjvm::checkException: exiting..."<<PEGASUS_STD(endl));
         env->ExceptionDescribe();
         exit(13);
      }
   }
}

/**************************************************************************
 * name         - NewPlatformString
 * description  - Returns a new Java string object for the specified
 *                platform string.
 * parameters   - env
 *                s     Platform encoded string
 * returns      - Java string object pointer or null (0)
 **************************************************************************/
jstring JMPIjvm::NewPlatformString (JNIEnv *env, char *s)
{
    size_t     len = strlen(s);
    jclass     cls;
    jmethodID  mid;
    jbyteArray ary;

    NULL_CHECK0(cls = (*env).FindClass("java/lang/String"));
    NULL_CHECK0(mid = (*env).GetMethodID(cls, "<init>", "([B)V"));

    ary = (*env).NewByteArray((jsize)len);
    if (ary != 0)
    {
        jstring str = 0;
        (*env).SetByteArrayRegion (ary,
                                   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);
}


// -------------------------------------
// ---
// -		CIMException
// ---
// -------------------------------------

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1new
  (JNIEnv *jEnv, jobject jThs)
{
   JMPIjvm::cacheIDs(jEnv);
   jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNew);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newS
  (JNIEnv *jEnv, jobject jThs, jstring jM)
{
   JMPIjvm::cacheIDs(jEnv);
   jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewSt,jM);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSO
  (JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1)
{
   JMPIjvm::cacheIDs(jEnv);
   jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewStOb,jM,jO1);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSOO
  (JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1, jobject jO2)
{
   JMPIjvm::cacheIDs(jEnv);
   jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewStObOb,jM,jO1,jO2);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstanceException__1newSOOO
  (JNIEnv *jEnv, jobject jThs, jstring jM, jobject jO1, jobject jO2, jobject jO3)
{
   JMPIjvm::cacheIDs(jEnv);
   jEnv->CallNonvirtualVoidMethod(jThs,JMPIjvm::jv.CIMExceptionClassRef,JMPIjvm::jv.CIMExceptionNewStObObOb,jM,jO1,jO2,jO3);
}



// -------------------------------------
// ---
// -		CIMOMHandle
// ---
// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getClass
  (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean lo,
         jboolean iq, jboolean ic, jobjectArray jPl)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   CIMPropertyList   pl;
   OperationContext  ctx;

   if (jPl)
      pl = getList (jEnv, jPl);
   else
      pl = CIMPropertyList ();

   try {
      CIMClass cls = ch->getClass (ctx,
                                   cop->getNameSpace (),
                                   cop->getClassName (),
                                   (Boolean)lo,
                                   (Boolean)iq,
                                   (Boolean)ic,
                                   pl);

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

   return 0;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createClass
  (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCl)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   CIMClass         *cl  = DEBUG_ConvertJavaToC (jint, CIMClass*, jCl);
   OperationContext  ctx;

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

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setClass
  (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCl)
{
   CIMOMHandle     *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath   *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   CIMClass        *cl  = DEBUG_ConvertJavaToC (jint, CIMClass*, jCl);
   OperationContext ctx;

   try {
     ch->modifyClass (ctx,
                      cop->getNameSpace (),
                      *cl);
   }
   Catch(jEnv);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteClass
   (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   OperationContext  ctx;

   try {
      ch->deleteClass (ctx,
                       cop->getNameSpace (),
                       cop->getClassName ());
   }
   Catch(jEnv);
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClassNames
  (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean deep)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   CIMNamespaceName  ns  = cop->getNameSpace ();
   OperationContext  ctx;

   try {
      Array<CIMName>        enm   = ch->enumerateClassNames (ctx,
                                                             cop->getNameSpace (),
                                                             cop->getClassName (),
                                                             (Boolean)deep);
      Array<CIMObjectPath> *enmop = new Array<CIMObjectPath> ();

      for (int i = 0, m = enm.size (); i < m; i++)
      {
         enmop->append (CIMObjectPath (String::EMPTY,
                                       ns,
                                       enm[i]));
      }

      return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, enmop);
   }
   Catch(jEnv);

   return 0;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateClasses
  (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean deep,
        jboolean lo, jboolean iq, jboolean ic)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   OperationContext  ctx;

   try {
      Array<CIMClass> en = ch->enumerateClasses (ctx,
                                                 cop->getNameSpace (),
                                                 cop->getClassName (),
                                                 (Boolean)deep,
                                                 (Boolean)lo,
                                                 (Boolean)iq,
                                                 (Boolean)ic);

      return DEBUG_ConvertCToJava (Array<CIMClass>*, jint, new Array<CIMClass> (en));
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getInstance
   (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean lo, jboolean iq, jboolean ic,
        jobjectArray jPl)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   OperationContext  ctx;
   CIMPropertyList   pl;

   if (jPl)
      pl = getList (jEnv,jPl);
   else
      pl = CIMPropertyList ();

   try {
      CIMInstance *inst = new CIMInstance (ch->getInstance (ctx,
                                                            cop->getNameSpace (),
                                                            *cop,
                                                            (Boolean)lo,
                                                            (Boolean)iq,
                                                            (Boolean)ic,
                                                            pl));

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

   return 0;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deleteInstance
   (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   OperationContext  ctx;

   try {
      ch->deleteInstance (ctx,cop->getNameSpace (),*cop);
   }
   Catch (jEnv);
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1createInstance
  (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCi)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   CIMInstance      *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);
   OperationContext  ctx;

   try {
      ci->setPath (*cop);

      CIMObjectPath obj = ch->createInstance (ctx,
                                              cop->getNameSpace (),
                                              *ci);

      return DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath (obj));
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1modifyInstance
  (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jint jCi,
         jboolean iq, jobjectArray jPl)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   CIMInstance      *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);
   CIMPropertyList   pl  = getList (jEnv, jPl);
   OperationContext  ctx;

   try {
      ci->setPath (*cop);
      ch->modifyInstance (ctx,
                          cop->getNameSpace (),
                          *ci,
                          (Boolean)iq,
                          pl);
   }
   Catch (jEnv);
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstanceNames
  (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean deep)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   OperationContext  ctx;

   try {
      Array<CIMObjectPath> enm = ch->enumerateInstanceNames (ctx,
                                                             cop->getNameSpace (),
                                                             cop->getClassName ()); //, (Boolean)deep);
      return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath> (enm));
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1enumerateInstances
  (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jboolean deep,
        jboolean lo, jboolean iq, jboolean ic, jobjectArray jPl)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   CIMPropertyList   pl;
   OperationContext  ctx;

   if (jPl)
      pl = getList (jEnv, jPl);
   else
      pl = CIMPropertyList ();

   try {
      Array<CIMInstance> en = ch->enumerateInstances (ctx,
                                                      cop->getNameSpace (),
                                                      cop->getClassName (),
                                                      (Boolean)deep,
                                                      (Boolean)lo,
                                                      (Boolean)iq,
                                                      (Boolean)ic,
                                                      pl);

      return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, new Array<CIMInstance> (en));
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1execQuery
  (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jQuery, jstring jQl)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   OperationContext  ctx;
   const char       *str = jEnv->GetStringUTFChars (jQuery,NULL);
   String            query (str);

   jEnv->ReleaseStringUTFChars (jQuery,str);

   str = jEnv->GetStringUTFChars (jQl, NULL);

   String ql (str);

   jEnv->ReleaseStringUTFChars (jQl, str);

   try {
      Array<CIMObject>    enm = ch->execQuery (ctx,
                                               cop->getNameSpace (),
                                               ql,
                                               query);
      Array<CIMInstance> *enmInst = new Array<CIMInstance> ();

      for (int i = 0,m = enm.size (); i<m; i++)
      {
         enmInst->append (CIMInstance (enm[i]));
      }

      return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);
   }
   Catch (jEnv);

   return 0;
}


JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1getProperty
   (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jN)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   OperationContext  ctx;
   const char       *str = jEnv->GetStringUTFChars (jN, NULL);
   CIMName           prop (str);

   jEnv->ReleaseStringUTFChars (jN, str);

   try {
      CIMValue *cv = new CIMValue (ch->getProperty (ctx,
                                                    cop->getNameSpace (),
                                                    *cop,
                                                    prop));

      return DEBUG_ConvertCToJava (CIMValue*, jint, cv);
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1setProperty
  (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jPn, jint jV)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   OperationContext  ctx;
   CIMValue         *val = (CIMValue*)jCop;
   const char       *str = jEnv->GetStringUTFChars (jPn, NULL);
   CIMName           pName (str);

   jEnv->ReleaseStringUTFChars (jPn, str);

   try {
      ch->setProperty (ctx,
                       cop->getNameSpace (),
                       *cop,
                       pName,
                       *val);
   }
   Catch (jEnv);
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod
  (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jMn, jobject jIn, jobject jOut)
{
   JMPIjvm::cacheIDs (jEnv);

   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   OperationContext  ctx;
   const char       *str = jEnv->GetStringUTFChars (jMn,NULL);
   CIMName           method (str);

   jEnv->ReleaseStringUTFChars (jMn,str);

   Array<CIMParamValue> in;
   Array<CIMParamValue> out;

   for (int i = 0, m = jEnv->CallIntMethod (jIn,JMPIjvm::jv.VectorSize); i < m; i++)
   {
       JMPIjvm::checkException (jEnv);

       jobject jProp = jEnv->CallObjectMethod (jIn,JMPIjvm::jv.VectorElementAt,i);

       JMPIjvm::checkException (jEnv);

       jint         jp = jEnv->CallIntMethod (jProp,JMPIjvm::jv.CIMPropertyCInst);
       CIMProperty *p  = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp);

       JMPIjvm::checkException (jEnv);

       in.append (CIMParamValue (p->getName ().getString (),p->getValue ()));
   }
   try {
      CIMValue *val = new CIMValue (ch->invokeMethod (ctx,
                                                      cop->getNameSpace (),
                                                      *cop,
                                                      method,
                                                      in,
                                                      out));

      for (int i = 0,m = out.size (); i<m; i++)
      {
         const CIMParamValue &parm = out[i];
         const CIMValue       v    = parm.getValue ();
         CIMProperty         *p    = new CIMProperty (parm.getParameterName (),
                                                      v,
                                                      v.getArraySize ());
         jint                 jp   = DEBUG_ConvertCToJava (CIMProperty*, jint, p);
         jobject              prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,
                                                      JMPIjvm::jv.CIMPropertyNewI,
                                                      jp);

         jEnv->CallVoidMethod (jOut, JMPIjvm::jv.VectorAddElement, prop);
      }
      return DEBUG_ConvertCToJava (CIMValue*, jint, val);
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1invokeMethod24
  (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop, jstring jMn,
        jobjectArray jIn, jobjectArray jOut)

{
   JMPIjvm::cacheIDs (jEnv);

   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   OperationContext  ctx;
   const char       *str = jEnv->GetStringUTFChars (jMn, NULL);
   CIMName           method (str);

   jEnv->ReleaseStringUTFChars (jMn, str);

   Array<CIMParamValue> in;
   Array<CIMParamValue> out;

   if (jIn)
   {
      for (int i = 0, m = jEnv->GetArrayLength (jIn); i < m; i++)
      {
          JMPIjvm::checkException (jEnv);

          jobject jArg = jEnv->GetObjectArrayElement (jIn,i);

          JMPIjvm::checkException (jEnv);

          jint           jp = jEnv->CallIntMethod (jArg,JMPIjvm::jv.CIMArgumentCInst);
          CIMParamValue *p  = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jp);

          JMPIjvm::checkException (jEnv);

          in.append (*p);
      }
   }
   try {
      CIMValue *val = new CIMValue (ch->invokeMethod (ctx,
                                                      cop->getNameSpace (),
                                                      *cop,
                                                      method,
                                                      in,
                                                      out));

      if (jOut)
      {
         for (int i = 0, m = out.size (), o = jEnv->GetArrayLength (jOut); i < m && i< o; i++)
         {
            CIMParamValue *parm  = new CIMParamValue (out[i]);
            jint           jParm = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);

            jEnv->SetObjectArrayElement (jOut,i,
                                        jEnv->NewObject (JMPIjvm::jv.CIMArgumentClassRef,JMPIjvm::jv.CIMArgumentNewI,jParm));
         }
      }
      return DEBUG_ConvertCToJava (CIMValue*, jint, val);
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associatorNames
  (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop,
   jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   OperationContext  ctx;
   const char       *str = jEnv->GetStringUTFChars (jAssocClass, NULL);

   CIMName           assocClass;

   if (  str
      && *str
      )
   {
      if (CIMName::legal (str))
      {
         assocClass = str;
      }
      else
      {
         jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
                                       JMPIjvm::jv.CIMExceptionNewISt,
                                       (jint)4, // CIM_ERR_INVALID_PARAMETER
                                       jEnv->NewStringUTF ("Invalid association class name"));

         jEnv->Throw ((jthrowable)ev);

         return 0;
      }
   }

   jEnv->ReleaseStringUTFChars (jAssocClass, str);

   str = jEnv->GetStringUTFChars (jResultClass, NULL);

   CIMName resultClass;

   if (  str
      && *str
      )
   {
      if (CIMName::legal (str))
      {
         resultClass = str;
      }
      else
      {
         jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
                                       JMPIjvm::jv.CIMExceptionNewISt,
                                       (jint)4, // CIM_ERR_INVALID_PARAMETER
                                       jEnv->NewStringUTF ("Invalid result class name"));

         jEnv->Throw ((jthrowable)ev);

         return 0;
      }
   }

   jEnv->ReleaseStringUTFChars (jResultClass, str);

   str = jEnv->GetStringUTFChars (jRole, NULL);

   String role (str);

   jEnv->ReleaseStringUTFChars (jRole, str);

   str = jEnv->GetStringUTFChars (jResultRole, NULL);

   String resultRole (str);

   jEnv->ReleaseStringUTFChars (jResultRole, str);

   try {
      Array<CIMObjectPath> enm = ch->associatorNames (ctx,
                                                      cop->getNameSpace (),
                                                      *cop,
                                                      assocClass,
                                                      resultClass,
                                                      role,
                                                      resultRole);

      return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath> (enm));
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1associators
  (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop,
   jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole,
   jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   OperationContext  ctx;
   CIMPropertyList   pl  = getList (jEnv, jPl);
   const char       *str = jEnv->GetStringUTFChars (jAssocClass, NULL);
   CIMName           assocClass;

   if (  str
      && *str
      )
   {
      if (CIMName::legal (str))
      {
         assocClass = str;
      }
      else
      {
         jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
                                       JMPIjvm::jv.CIMExceptionNewISt,
                                       (jint)4, // CIM_ERR_INVALID_PARAMETER
                                       jEnv->NewStringUTF ("Invalid association class name"));

         jEnv->Throw ((jthrowable)ev);

         return 0;
      }
   }

   jEnv->ReleaseStringUTFChars (jAssocClass, str);

   str = jEnv->GetStringUTFChars (jResultClass, NULL);

   CIMName resultClass;

   if (  str
      && *str
      )
   {
      if (CIMName::legal (str))
      {
         resultClass = str;
      }
      else
      {
         jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
                                       JMPIjvm::jv.CIMExceptionNewISt,
                                       (jint)4, // CIM_ERR_INVALID_PARAMETER
                                       jEnv->NewStringUTF ("Invalid result class name"));

         jEnv->Throw ((jthrowable)ev);

         return 0;
      }
   }

   jEnv->ReleaseStringUTFChars (jResultClass, str);

   str = jEnv->GetStringUTFChars (jRole, NULL);

   String role (str);

   jEnv->ReleaseStringUTFChars (jRole, str);

   str = jEnv->GetStringUTFChars (jResultRole, NULL);

   String resultRole (str);

   jEnv->ReleaseStringUTFChars (jResultRole, str);

   try {
      Array<CIMObject>    enm     = ch->associators (ctx,
                                                     cop->getNameSpace (),
                                                     *cop,
                                                     assocClass,
                                                     resultClass,
                                                     role,
                                                     resultRole,
                                                     (Boolean)includeQualifiers,
                                                     (Boolean)includeClassOrigin,
                                                     pl);
      Array<CIMInstance> *enmInst = new Array<CIMInstance> ();

      for (int i = 0,m = enm.size (); i<m; i++)
      {
         enmInst->append (CIMInstance (enm[i]));
      }

      return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1referenceNames
  (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop,
   jstring jAssocClass, jstring jRole)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   OperationContext  ctx;
   const char       *str = jEnv->GetStringUTFChars (jAssocClass, NULL);
   CIMName           assocClass;

   if (  str
      && *str
      )
   {
      if (CIMName::legal (str))
      {
         assocClass = str;
      }
      else
      {
         jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
                                       JMPIjvm::jv.CIMExceptionNewISt,
                                       (jint)4, // CIM_ERR_INVALID_PARAMETER
                                       jEnv->NewStringUTF ("Invalid association class name"));

         jEnv->Throw ((jthrowable)ev);

         return 0;
      }
   }

   jEnv->ReleaseStringUTFChars (jAssocClass, str);

   str = jEnv->GetStringUTFChars (jRole, NULL);

   String role (str);

   jEnv->ReleaseStringUTFChars (jRole, str);

   try {
      Array<CIMObjectPath> enm = ch->referenceNames (ctx,
                                                     cop->getNameSpace (),
                                                     *cop,
                                                     assocClass,
                                                     role);

      return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath> (enm));
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1references
  (JNIEnv *jEnv, jobject jThs, jint jCh, jint jCop,
   jstring jAssocClass, jstring jRole,
   jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)
{
   CIMOMHandle      *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   OperationContext  ctx;
   CIMPropertyList   pl  = getList (jEnv, jPl);
   const char       *str = jEnv->GetStringUTFChars (jAssocClass, NULL);
   CIMName           assocClass;

   if (  str
      && *str
      )
   {
      if (CIMName::legal (str))
      {
         assocClass = str;
      }
      else
      {
         jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
                                       JMPIjvm::jv.CIMExceptionNewISt,
                                       (jint)4, // CIM_ERR_INVALID_PARAMETER
                                       jEnv->NewStringUTF ("Invalid association class name"));

         jEnv->Throw ((jthrowable)ev);

         return 0;
      }
   }

   jEnv->ReleaseStringUTFChars (jAssocClass, str);

   str = jEnv->GetStringUTFChars (jRole, NULL);

   String role (str);

   jEnv->ReleaseStringUTFChars (jRole, str);

   try {
      Array<CIMObject>    enm     = ch->references (ctx,
                                                    cop->getNameSpace (),
                                                    *cop,
                                                    assocClass,
                                                    role,
                                                    (Boolean)includeQualifiers,
                                                    (Boolean)includeClassOrigin,
                                                    pl);
      Array<CIMInstance> *enmInst = new Array<CIMInstance> ();

      for (int i = 0, m = enm.size (); i < m; i++)
      {
         enmInst->append (CIMInstance (enm[i]));
      }

      return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent
   (JNIEnv *jEnv, jobject jThs, jint jCh, jstring jName, jstring jNs, jint jInd)
{
   CIMOMHandle *ch  = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);
   CIMInstance *ind = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInd);
   const char  *str = jEnv->GetStringUTFChars (jName, NULL);
   String       name (str);

   jEnv->ReleaseStringUTFChars (jName, str);

   str = jEnv->GetStringUTFChars (jNs, NULL);

   String ns (str);

   jEnv->ReleaseStringUTFChars (jNs, str);

   CIMObjectPath ref (ind->getPath ());

   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);
   DDD (PEGASUS_STD (cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent () ind = "<<ind->getPath ().toString ()<<PEGASUS_STD (endl));

   JMPIProviderManager::indProvRecord   *prec        = NULL;
   String                                sPathString = ind->getPath ().toString ();
   OperationContext                     *context     = NULL;
   bool                                  fResult     = false;

   {
      AutoMutex lock (JMPIProviderManager::mutexProvTab);

      fResult = JMPIProviderManager::provTab.lookup (name, prec);

      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);
      }
   }
   else
   {
      DDD (PEGASUS_STD (cerr)<<"--- Java_org_pegasus_jmpi_CIMOMHandle__1deliverEvent () provider name \""<<name<<"\" not found"<<PEGASUS_STD (endl));
   }
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMOMHandle__1finalize
   (JNIEnv *jEnv, jobject jThs, jint jCh)
{
   CIMOMHandle *ch = DEBUG_ConvertJavaToC (jint, CIMOMHandle*, jCh);

   delete ch;

   DEBUG_ConvertCleanup (jint, jCh);
}

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

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

   try {
      CIMInstance *ci = new CIMInstance (cls->getClassName ());

      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*, jint, ci);
   }
   Catch (jEnv);

   return 0;
}

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

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

      return str;
   }
   Catch (jEnv);

   return 0;
}

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

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

   jEnv->ReleaseStringUTFChars (jN,str);

   return rv;
}

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

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

   jEnv->ReleaseStringUTFChars (jN,str);

   return rv;
}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1hasQualifier
     (JNIEnv *jEnv, jobject jThs, jint jCls, jstring jQ)
{
   CIMClass   *cls = DEBUG_ConvertJavaToC (jint, 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 jobject JNICALL Java_org_pegasus_jmpi_CIMClass__1getProperties
      (JNIEnv *jEnv, jobject jThs, jint jCls, jobject jVec)
{
   JMPIjvm::cacheIDs (jEnv);

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

   for (int i = 0, s = cls->getPropertyCount (); i < s; i++)
   {
      CIMProperty *cp  = new CIMProperty (cls->getProperty (i));
      jint         jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp);

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

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

   return jVec;
}

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

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

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

   CIMClass *cls = DEBUG_ConvertJavaToC (jint, 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));
      jint         jp = jEnv->CallIntMethod (o,JMPIjvm::jv.CIMPropertyCInst);
      CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp);

      JMPIjvm::checkException (jEnv);

      cls->addProperty (*cp);
   }
}

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

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

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

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

   return jVec;
}

JNIEXPORT jint 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*, jint, cls);
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMClass__1getSuperClass
      (JNIEnv *jEnv, jobject jThs, jint jCls)
{
   CIMClass     *cls = DEBUG_ConvertJavaToC (jint, 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, jint jCls, jobject jVec)
{
   JMPIjvm::cacheIDs (jEnv);

   CIMClass *cls = DEBUG_ConvertJavaToC (jint, 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));
            jint         jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp);

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

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

   return jVec;
}

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

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

   jEnv->ReleaseStringUTFChars (jN,str);

   return rv;
}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMClass__1equals
      (JNIEnv *jEnv, jobject jThs, jint jCls, jint jClsToBeCompared)
{
   CIMClass *cls             = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);
   CIMClass *clsToBeCompared = DEBUG_ConvertJavaToC (jint, 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, jint jCls)
{
   CIMClass *cls = DEBUG_ConvertJavaToC (jint, CIMClass*, jCls);

   delete cls;

   DEBUG_ConvertCleanup (jint, jCls);
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClass__1filterProperties
      (JNIEnv *jEnv, jobject jThs, jint jInst, jobjectArray jPl, jboolean iq, jboolean ic, jboolean lo)
{
   CIMClass *cc   = DEBUG_ConvertJavaToC (jint, 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*, jint, 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*, jint, 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*, jint, cf);
}



// -------------------------------------
// ---
// -		CIMInstance
// ---

// -------------------------------------
JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1new
      (JNIEnv *jEnv, jobject jThs)
{
   return DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance ());
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1newCn
      (JNIEnv *jEnv, jobject jThs, jstring jN)
{
   const char *str = jEnv->GetStringUTFChars (jN,NULL);
   CIMInstance *ci = new CIMInstance (CIMName (str));

   jEnv->ReleaseStringUTFChars (jN,str);

   return DEBUG_ConvertCToJava (CIMInstance*, jint, ci);
}

//Added by Andy Viciu
JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setName
      (JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN)
{
   CIMInstance *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
   const char  *str = jEnv->GetStringUTFChars (jN,NULL);

   jEnv->ReleaseStringUTFChars (jN,str);

   /* NOT SUPPORTED AND NOT NEEDED*/
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperty
      (JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN, jint jV)
{
   CIMInstance *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
   CIMValue    *cv  = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);
   const char  *str = jEnv->GetStringUTFChars (jN,NULL);
   Uint32       pos = ci->findProperty (CIMName (str));

   try {
      if (pos!= PEG_NOT_FOUND)
      {
         CIMProperty cp = ci->getProperty (pos);

         if (cp.getType () == cv->getType ())
         {
            cp.setValue (*cv);
         }
         else
         {
            DDD (PEGASUS_STD (cerr)<<"!!! CIMInstance.setProperty - Wrong type of CIMValue (instance name:"<<ci->getClassName ().getString ()<<", property name: "<<str<<")");
            DDD (PEGASUS_STD (cerr)<<"!!! CIMInstance.setProperty : "<<cp.getType ()<<" <> "<<cv->getType ()<<PEGASUS_STD (endl));

            throw CIMException (CIM_ERR_FAILED, String ("Type mismatch"));
         }

         ci->removeProperty (pos);
         ci->addProperty (cp);
      }
      else
      {
         CIMProperty *cp = new CIMProperty (CIMName (str),*cv);
         ci->addProperty (*cp);
      }
   }
   Catch (jEnv);

   jEnv->ReleaseStringUTFChars (jN,str);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1setProperties
      (JNIEnv *jEnv, jobject jThs, jint jInst, jobject jV)
{
   throw CIMException (CIM_ERR_NOT_SUPPORTED, String ("Not yet supported"));
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperty
      (JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN)
{
   CIMInstance *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
   const char  *str = jEnv->GetStringUTFChars (jN,NULL);
   jint         rv  = 0;

   try {
      Uint32 pos = ci->findProperty (CIMName (str));

      if (pos != PEG_NOT_FOUND)
      {
         CIMProperty *cp = new CIMProperty (ci->getProperty (pos));

         rv = DEBUG_ConvertCToJava (CIMProperty*, jint, cp);
      }
   }
   Catch (jEnv);

   jEnv->ReleaseStringUTFChars (jN,str);

   return rv;
}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getKeyValuePairs
      (JNIEnv *jEnv, jobject jThs, jint jInst, jobject jVec)
{
   JMPIjvm::cacheIDs (jEnv);

   CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);

//@HACK
//cout << "ci->getPropertyCount () = " << ci->getPropertyCount () << endl;
   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)
      {
         CIMProperty *cp  = new CIMProperty (ci->getProperty (i));
         jint         jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp);

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

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

   return jVec;
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMInstance__1getClassName
      (JNIEnv *jEnv, jobject jThs, jint jInst)
{
   CIMInstance  *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
   const String &cn = ci->getClassName ().getString ();

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

   return str;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1getQualifier
      (JNIEnv *jEnv, jobject jThs, jint jInst, jstring jN)
{
   CIMInstance *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
   const char  *str = jEnv->GetStringUTFChars (jN,NULL);
   jint         rv  = 0;
   Uint32       pos = ci->findQualifier (String (str));

   if (pos!= PEG_NOT_FOUND)
   {
      rv = DEBUG_ConvertCToJava (CIMQualifier*, jint, new CIMQualifier (ci->getQualifier (pos)));
   }

   jEnv->ReleaseStringUTFChars (jN,str);

   return rv;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1clone
      (JNIEnv *jEnv, jobject jThs, jint jInst)
{
   CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
   CIMInstance *cl = new CIMInstance (ci->clone ());

   return DEBUG_ConvertCToJava (CIMInstance*, jint, cl);
}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMInstance__1getProperties
      (JNIEnv *jEnv, jobject jThs, jint jInst, jobject jVec)
{
   JMPIjvm::cacheIDs (jEnv);

   CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);

   for (int i = 0, s = ci->getPropertyCount (); i < s; i++)
   {
      CIMProperty *cp  = new CIMProperty (ci->getProperty (i));
      jint         jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp);

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

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

   return jVec;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMInstance__1finalize
      (JNIEnv *jEnv, jobject jThs, jint jInst)
{
   CIMInstance *ci = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);

   delete ci;

   DEBUG_ConvertCleanup (jint, jInst);
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMInstance__1filterProperties
      (JNIEnv *jEnv, jobject jThs, jint jInst, jobjectArray jPl, jboolean iq, jboolean ic, jboolean lo)
{
   CIMInstance *ci   = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
   CIMInstance *cf   = 0;
   CIMName      clsn = ci->getClassName ();

   if (lo)
   {
      cf = new CIMInstance (ci->clone ());
      CIMName clsn = ci->getClassName ();
      for (int i = cf->getPropertyCount ()-1; i>= 0; i--)
      {
         if (cf->getProperty (i).getClassOrigin () == clsn)
            cf->removeProperty (i);
      }
      return DEBUG_ConvertCToJava (CIMInstance*, jint, cf);
   }
   else if (jPl)
   {
      CIMPropertyList pl = getList (jEnv,jPl);
      Array<CIMName> n = pl.getPropertyNameArray ();
      cf = new CIMInstance (clsn);
      for (int i = 0, s = n.size (); i < s; i++)
      {
         Uint32 pos = ci->findProperty (n[i]);
         if (pos!= PEG_NOT_FOUND)
         {
            if (iq)
            {
               CIMProperty cp = ci->getProperty (pos).clone ();
               if (!ic)
                  cp.setClassOrigin (CIMName ());
               cf->addProperty (cp);
            }
            else
            {
               CIMProperty cp = ci->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);
            }
         }
      }
      cf->setPath (ci->getPath ());
   }
   else if (iq)
   {
      cf = new CIMInstance (ci->clone ());
      if (ic)
         return DEBUG_ConvertCToJava (CIMInstance*, jint, 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 CIMInstance (clsn);
      for (int i = ci->getPropertyCount () - 1; i >= 0; i--)
      {
         CIMProperty cp = ci->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);
      }
      cf->setPath (ci->getPath ());
   }

   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* construct ()
{
   CIMObjectPath *cop = new CIMObjectPath ();
   _nameSpace     n;

   cop->setNameSpace (n.nameSpace ());
   cop->setHost (n.hostName ());

   return cop;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1new
      (JNIEnv *jEnv, jobject jThs)
{
   return DEBUG_ConvertCToJava (CIMObjectPath*, jint, construct ());
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCn
      (JNIEnv *jEnv, jobject jThs, jstring jCn)
{
   CIMObjectPath *cop = construct ();
   const char    *str = jEnv->GetStringUTFChars (jCn,NULL);

   if (str)
      cop->setClassName (str);

   jEnv->ReleaseStringUTFChars (jCn,str);

   return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1newCnNs
      (JNIEnv *jEnv, jobject jThs, jstring jCn, jstring jNs)
{
   CIMObjectPath *cop  = construct ();
   const char    *str1 = NULL;
   const char    *str2 = NULL;

   try {
      if (jCn)
         str1 = jEnv->GetStringUTFChars (jCn,NULL);
      if (jNs)
         str2 = jEnv->GetStringUTFChars (jNs,NULL);
      if (str1)
         cop->setClassName (str1);
      if (str2)
         cop->setNameSpace (str2);
   }
   Catch (jEnv);

   if (str1)
      jEnv->ReleaseStringUTFChars (jCn,str1);
   if (str2)
   jEnv->ReleaseStringUTFChars (jNs,str2);

   return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1_newCi
      (JNIEnv *jEnv, jobject jThs, jint jInst)
{
   CIMInstance   *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jInst);
   CIMObjectPath *cop = new CIMObjectPath (ci->getPath ());
   _nameSpace     n;

   if (cop->getNameSpace ().isNull ())
      cop->setNameSpace (n.nameSpace ());
   if (cop->getHost () == NULL)
      cop->setHost (n.hostName ());

   return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1finalize
      (JNIEnv *jEnv, jobject jThs, jint jCop)
{
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

   delete cop;

   DEBUG_ConvertCleanup (jint, jCop);
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getHost
      (JNIEnv *jEnv, jobject jThs, jint jCop)
{
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   const String  &hn = cop->getHost ();

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

   return str;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setHost
      (JNIEnv *jEnv, jobject jThs, jint jCop, jstring jName)
{
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   const char    *str = jEnv->GetStringUTFChars (jName,NULL);

   cop->setHost (String (str));

   jEnv->ReleaseStringUTFChars (jName,str);
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getObjectName
      (JNIEnv *jEnv, jobject jThs, jint jCop)
{
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   const String  &cn  = cop->getClassName ().getString ();

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

   return str;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setObjectName
      (JNIEnv *jEnv, jobject jThs, jint jCop, jstring jName)
{
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   const char    *str = jEnv->GetStringUTFChars (jName,NULL);

   cop->setClassName (String (str));

   jEnv->ReleaseStringUTFChars (jName,str);
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getNameSpace
      (JNIEnv *jEnv, jobject jThs, jint jCop)
{
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   const String  &ns  = cop->getNameSpace ().getString ();

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

   return str;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setNameSpace
      (JNIEnv *jEnv, jobject jThs, jint jCop, jstring jName)
{
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   const char    *str = jEnv->GetStringUTFChars (jName,NULL);

   cop->setNameSpace (CIMNamespaceName (str));

   jEnv->ReleaseStringUTFChars (jName,str);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1addKey
      (JNIEnv *jEnv, jobject jThs, jint jCop, jstring jId, jint jVal)
{
   CIMObjectPath       *cop         = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   const char          *str         = jEnv->GetStringUTFChars (jId,NULL);
   CIMValue            *cv          = DEBUG_ConvertJavaToC (jint, CIMValue*, jVal);
   Array<CIMKeyBinding> keyBindings = cop->getKeyBindings ();

   keyBindings.append (CIMKeyBinding (str,*cv));
   cop->setKeyBindings (Array<CIMKeyBinding> (keyBindings));

   jEnv->ReleaseStringUTFChars (jId,str);
}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeys
      (JNIEnv *jEnv, jobject jThs, jint jCop, jobject jVec)
{
   JMPIjvm::cacheIDs (jEnv);

   CIMObjectPath              *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   const Array<CIMKeyBinding> &akb = cop->getKeyBindings ();

   for (Uint32 i = 0, s = akb.size (); i < s; i++)
   {
      const String &n = akb[i].getName ().getString ();
      const String &v = akb[i].getValue ();
      CIMKeyBinding::Type t = akb[i].getType ();
      CIMValue *cv = 0;
      switch (t) {
      case CIMKeyBinding::NUMERIC:
         cv = new CIMValue ((Sint32)atol (v.getCString ()));
         break;
      case CIMKeyBinding::STRING:
         cv = new CIMValue (v);
         break;
      case CIMKeyBinding::BOOLEAN:
         cv = new CIMValue ((Boolean) (v.getCString ()));
         break;
      case CIMKeyBinding::REFERENCE:
         cv = new CIMValue (CIMObjectPath (akb[i].getValue ()));
         break;
      default:
         throwCIMException (jEnv,"+++ unsupported type: ");
      }

      CIMProperty *cp = 0;
      if (t!= CIMKeyBinding::REFERENCE)
         cp = new CIMProperty (n,*cv);
      else
         cp = new CIMProperty (n,*cv, 0, ((CIMObjectPath) akb[i].getValue ()).getClassName ());

      jint    jCp  = DEBUG_ConvertCToJava (CIMProperty*, jint, cp);
      jobject prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jCp);

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

   return jVec;
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1getKeyValue
      (JNIEnv *jEnv, jobject jThs, jint jCop, jstring jStr)
{
   CIMObjectPath              *cop        = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   const Array<CIMKeyBinding> &akb        = cop->getKeyBindings ();
   const char                 *strKeyName = jEnv->GetStringUTFChars (jStr,NULL);
   jstring                     retStr     = NULL;

   for (Uint32 i = 0,s = akb.size (); i<s; i++)
   {
      const String &n = akb[i].getName ().getString ();

      if (n == String (strKeyName))
      {
         retStr = jEnv->NewStringUTF (akb[i].getValue ().getCString ());
         break;
      }
   }

   jEnv->ReleaseStringUTFChars (jStr,strKeyName);

   return retStr;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1set
      (JNIEnv *jEnv, jobject jThs, jstring jStr)
{
   const char    *strCop = jEnv->GetStringUTFChars (jStr,NULL);
   CIMObjectPath *cop    = new CIMObjectPath ();

   cop->set (String (strCop));

   jEnv->ReleaseStringUTFChars (jStr,strCop);

   return DEBUG_ConvertCToJava (CIMObjectPath*, jint, cop);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1setKeys
      (JNIEnv *jEnv, jobject jThs, jint jCop, jobject jVec)
{
   JMPIjvm::cacheIDs (jEnv);

   CIMObjectPath        *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   Array<CIMKeyBinding>  akb;

   for (Uint32 i = 0, s = jEnv->CallIntMethod (jVec,JMPIjvm::jv.VectorSize); i < s; i++)
   {
      jobject o = jEnv->CallObjectMethod (jVec,JMPIjvm::jv.VectorElementAt, (i));

      jint         jCp = jEnv->CallIntMethod (o,JMPIjvm::jv.CIMPropertyCInst);
      CIMProperty *cp  = DEBUG_ConvertJavaToC (jint, CIMProperty*, jCp);

      akb.append (CIMKeyBinding (cp->getName (),cp->getValue ()));
   }
   cop->setKeyBindings (akb);
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1clone
      (JNIEnv *jEnv, jobject jThs, jint jCop)
{
   CIMObjectPath *cop  = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   CIMObjectPath *copl = new CIMObjectPath (cop->getHost (), cop->getNameSpace (), cop->getClassName (), cop->getKeyBindings ());

   return DEBUG_ConvertCToJava (CIMObjectPath*, jint, copl);
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMObjectPath__1toString
      (JNIEnv *jEnv, jobject jThs, jint jCop)
{
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   const String  &ns  = cop->toString ();

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

   return str;
}

// -------------------------------------
// ---
// -		CIMDataType
// ---
// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1new
  (JNIEnv *jEnv, jobject jThs, jint type)
{
  return DEBUG_ConvertCToJava (_dataType*, jint, new _dataType (type));
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newAr
  (JNIEnv *jEnv, jobject jThs, jint type, jint size)
{
  return DEBUG_ConvertCToJava (_dataType*, jint, new _dataType (type,size));
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1newRef
  (JNIEnv *jEnv, jobject jThs, jint type, jstring jRef)
{
   const char *ref   = jEnv->GetStringUTFChars (jRef,NULL);
   jint        cInst = DEBUG_ConvertCToJava (_dataType*, jint, new _dataType (type,String (ref)));

   jEnv->ReleaseStringUTFChars (jRef,ref);

   return cInst;
}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isArray
  (JNIEnv *jEnv, jobject jThs, jint jDt)
{
   _dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);

   return dt->_array == true;
}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isreference
  (JNIEnv *jEnv, jobject jThs, jint jDt)
{
   _dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);

   return dt->_reference == true;
}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDataType__1isReference
  (JNIEnv *jEnv, jobject jThs, jint jDt)
{
   _dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);

   return dt->_reference == true;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getType
  (JNIEnv *jEnv, jobject jThs, jint jDt)
{
   _dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);

   return dt->_type;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDataType__1getSize
  (JNIEnv *jEnv, jobject jThs, jint jDt)
{
   _dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);

   return dt->_size;
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1getRefClassName
  (JNIEnv *jEnv, jobject jThs, jint jDt)
{
   _dataType *dt  = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);
   jstring    str = jEnv->NewStringUTF (dt->_refClass.getCString ());

   return str;
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMDataType__1toString
  (JNIEnv *jEnv, jobject jThs, jint jDt)
{
   _dataType *dt  = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);
   jstring    str = NULL;

   if (dt->_type & 0x10)
   {
      bool   fSuccess = false;
      String tmp      = _dataType::convertJavaTypeToChars (dt->_type-0x10, &fSuccess);

      if (!fSuccess)
         return str;

      tmp = tmp + "[]";

      str = jEnv->NewStringUTF (tmp.getCString ());
   }
   else if (dt->_type == 0x20 + 1) // REFERENCE
   {
      String tmp = dt->_refClass + " REF";

      str = jEnv->NewStringUTF (tmp.getCString ());
   }
   else
   {
      bool  fSuccess = false;
      char *tmp      = _dataType::convertJavaTypeToChars (dt->_type, &fSuccess);

      if (!fSuccess)
         return str;

      str = jEnv->NewStringUTF (tmp);
   }

   return str;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDataType__1finalize
      (JNIEnv *jEnv, jobject jThs, jint jDt)
{
   _dataType *dt = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);

   delete dt;

   DEBUG_ConvertCleanup (jint, jDt);
}


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

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

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

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

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

JNIEXPORT jint 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*, jint, p);
}

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

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

   jEnv->ReleaseStringUTFChars (jN, str);

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

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

   cp->setValue (*cv);
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMArgument__1getName
      (JNIEnv *jEnv, jobject jThs, jint jP)
{
   CIMParamValue *cp  = DEBUG_ConvertJavaToC (jint, 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, jint jP, jstring jN)
{
   CIMParamValue *cp  = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jP);
   const char    *str = jEnv->GetStringUTFChars (jN,NULL);
   String         n (str);

   cp->setParameterName (n);

   jEnv->ReleaseStringUTFChars (jN,str);
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMArgument__1getType
      (JNIEnv *jEnv, jobject jThs, jint jP)
{
   CIMParamValue *cp       = DEBUG_ConvertJavaToC (jint, 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*, jint, type);
}


// -------------------------------------
// ---
// -		CIMProperty
// ---
// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getValue
      (JNIEnv *jEnv, jobject jThs, jint jP)
{
   CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
   CIMValue    *cv = new CIMValue (cp->getValue ());

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1new
      (JNIEnv *jEnv, jobject jThs, jstring jN, jint jV)
{
   CIMProperty *p = new CIMProperty (CIMName (),CIMValue ());

   return DEBUG_ConvertCToJava (CIMProperty*, jint, p);
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1property
      (JNIEnv *jEnv, jobject jThs, jstring jN, jint jV)
{
   CIMValue    *cv  = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);
   const char  *str = jEnv->GetStringUTFChars (jN,NULL);
   CIMProperty *cp  = 0;
   jint         jCp = 0;

   try {
      if (cv->getType ()!= CIMTYPE_REFERENCE)
      {
         cp = new CIMProperty (String (str),*cv);
      }
      else
      {
         if (!cv->isArray ())
         {
            CIMObjectPath cop;

            cv->get (cop);
            cp = new CIMProperty (String (str),*cv,0, cop.getClassName ());
         }
         else
         {
            throwCIMException (jEnv,"+++ unsupported type in CIMProperty.property");
         }
      }

      jCp = DEBUG_ConvertCToJava (CIMProperty*, jint, cp);
   }
   Catch (jEnv);

   jEnv->ReleaseStringUTFChars (jN,str);

   return jCp;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setValue
      (JNIEnv *jEnv, jobject jThs, jint jP,jint jV)
{
   CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
   CIMValue    *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);

   cp->setValue (*cv);
}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isArray
      (JNIEnv *jEnv, jobject jThs, jint jP)
{
   CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);

   return (jboolean)cp->isArray ();
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addValue
      (JNIEnv *jEnv, jobject jThs, jint jP, jint jV)
{
   CIMProperty *cp   = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
   CIMValue    *cvin = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);
   CIMValue     cv   = cp->getValue ();

   if (cvin->isNull ())
      throwCIMException (jEnv,"+++ null cvin value ");
   if (!cv.isArray ())
      throwCIMException (jEnv,"+++ not an array ");
   if (cvin->getType ()!= cv.getType ())
      throwCIMException (jEnv,"+++ type mismatch ");

   CIMType type = cv.getType ();

   switch (type) {
   case CIMTYPE_BOOLEAN: {
         Boolean bo;
         cvin->get (bo);
         Array<Boolean> boarr;
         cv.get (boarr);
         boarr.append (bo);
      }
      break;
   case CIMTYPE_UINT8: {
         Uint8 u8;
         cvin->get (u8);
         Array<Uint8> u8arr;
         cv.get (u8arr);
         u8arr.append (u8);
      }
      break;
   case CIMTYPE_SINT8: {
         Sint8 s8;
         cvin->get (s8);
         Array<Sint8> s8arr;
         cv.get (s8arr);
         s8arr.append (s8);
      }
      break;
   case CIMTYPE_UINT16: {
         Uint16 u16;
         cvin->get (u16);
         Array<Uint16> u16arr;
         cv.get (u16arr);
         u16arr.append (u16);
      }
      break;
   case CIMTYPE_SINT16: {
         Sint16 s16;
         cvin->get (s16);
         Array<Sint16> s16arr;
         cv.get (s16arr);
         s16arr.append (s16);
      }
      break;
   case CIMTYPE_UINT32: {
         Uint32 u32;
         cvin->get (u32);
         Array<Uint32> u32arr;
         cv.get (u32arr);
         u32arr.append (u32);
      }
      break;
   case CIMTYPE_SINT32: {
         Sint32 s32;
         cvin->get (s32);
         Array<Sint32> s32arr;
         cv.get (s32arr);
         s32arr.append (s32);
      }
      break;
   case CIMTYPE_UINT64: {
         Uint64 u64;
         cvin->get (u64);
         Array<Uint64> u64arr;
         cv.get (u64arr);
         u64arr.append (u64);
      }
      break;
   case CIMTYPE_SINT64: {
         Sint64 s64;
         cvin->get (s64);
         Array<Sint64> s64arr;
         cv.get (s64arr);
         s64arr.append (s64);
      }
      break;
   case CIMTYPE_REAL32: {
         Real32 f;
         cvin->get (f);
         Array<Real32> farr;
         cv.get (farr);
         farr.append (f);
      }
      break;
   case CIMTYPE_REAL64: {
         Real64 d;
         cvin->get (d);
         Array<Real64> darr;
         cv.get (darr);
         darr.append (d);
      }
      break;
   case CIMTYPE_CHAR16: {
         Char16 c16;
         cvin->get (c16);
         Array<Char16> c16arr;
         cv.get (c16arr);
         c16arr.append (c16);
      }
      break;
   case CIMTYPE_STRING: {
         String str;
         cvin->get (str);
         Array<String> strarr;
         cv.get (strarr);
         strarr.append (str);
      }
      break;
   case CIMTYPE_DATETIME: {
         CIMDateTime dt;
         cvin->get (dt);
         Array<CIMDateTime> dtarr;
         cv.get (dtarr);
         dtarr.append (dt);
      }
      break;
   case CIMTYPE_REFERENCE: {
         CIMObjectPath ref;
         cvin->get (ref);
         Array<CIMObjectPath> refarr;
         cv.get (refarr);
         refarr.append (ref);
      }
      break;
   case CIMTYPE_OBJECT: {
         CIMObject obj;
         cvin->get (obj);
         Array<CIMObject> objarr;
         cv.get (objarr);
         objarr.append (obj);
      }
      break;
   default:
      throwCIMException (jEnv,"+++ unsupported type ");
   }
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1addQualifier
      (JNIEnv *jEnv, jobject jThs, jint jP, jint jQ)
{
   CIMProperty  *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
   CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);

   cp->addQualifier (*cq);
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getName
      (JNIEnv *jEnv, jobject jThs, jint jP)
{
   CIMProperty  *cp  = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
   const String &n   = cp->getName ().getString ();
   jstring       str = jEnv->NewStringUTF (n.getCString ());

   return str;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1setName
      (JNIEnv *jEnv, jobject jThs, jint jP, jstring jN)
{
   CIMProperty *cp  = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
   const char  *str = jEnv->GetStringUTFChars (jN,NULL);

   cp->setName (CIMName (str));

   jEnv->ReleaseStringUTFChars (jN,str);
}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMProperty__1isReference
      (JNIEnv *jEnv, jobject jThs, jint jP)
{
   CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);

   return (jboolean) (cp->getType () == CIMTYPE_REFERENCE);
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMProperty__1getRefClassName
     (JNIEnv *jEnv, jobject jThs, jint jP)
{
   CIMProperty   *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
   const String  &n  = cp->getReferenceClassName ().getString ();

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

   return str;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1getType
      (JNIEnv *jEnv, jobject jThs, jint jP)
{
   CIMProperty  *cp        = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
   String        ref       = cp->getReferenceClassName ().getString ();
   bool           fSuccess = false;
   int            iJType   = 0;
   _dataType     *type     = 0;

   iJType = _dataType::convertCTypeToJavaType (cp->getType (), &fSuccess);

   if (fSuccess)
   {
      type = new _dataType (iJType,
                            cp->getArraySize (),
                            ref.size () ? true : false,
                            false,
                            cp->isArray (),
                            ref,
                            true);
   }

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMProperty__1setType
      (JNIEnv *jEnv, jobject jThs, jint jP, jint jDt)
{
   CIMProperty  *cp       = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
   _dataType    *dt       = DEBUG_ConvertJavaToC (jint, _dataType*, jDt);
   CIMValue      val;
   bool          fSuccess = false;
   CIMType       cType    = CIMTYPE_BOOLEAN;

   cType = _dataType::convertJavaTypeToCType (dt->_type, &fSuccess);

   if (fSuccess)
   {
      val.setNullValue (cType, dt->_array);

      CIMProperty *np = new CIMProperty (cp->getName (), val);

      delete cp;

      DEBUG_ConvertCleanup (jint, jP);

      return DEBUG_ConvertCToJava (CIMProperty*, jint, np);
   }
   else
   {
      return DEBUG_ConvertCToJava (CIMProperty*, jint, cp);
   }
}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMProperty__1getIdentifier
      (JNIEnv *jEnv, jobject jThs, jint jP)
{
   CIMProperty  *cp  = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);
   const String &n   = cp->getName ().getString ();
   jstring       str = jEnv->NewStringUTF (n.getCString ());

   return str;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMProperty__1finalize
      (JNIEnv *jEnv, jobject jThs, jint jP)
{
   CIMProperty *cp = DEBUG_ConvertJavaToC (jint, CIMProperty*, jP);

   delete cp;

   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
// ---
// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1new
      (JNIEnv *jEnv, jobject jThs)
{
   CIMQualifierDecl *qual = new CIMQualifierDecl ();

   return DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, qual);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1finalize
      (JNIEnv *jEnv, jobject jThs, jint jQ)
{
   CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ);

   delete qt;

   DEBUG_ConvertCleanup (jint, jQ);
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1getName
      (JNIEnv *jEnv, jobject jThs, jint jQ)
{
   CIMQualifierDecl *qt  = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ);
   const String     &n   = qt->getName ().getString ();
   jstring           str = jEnv->NewStringUTF (n.getCString ());

   return str;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setName
      (JNIEnv *jEnv, jobject jThs, jint jQ, jstring jN)
{
   CIMQualifierDecl *qt   = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ);
   const char       *str  = jEnv->GetStringUTFChars (jN,NULL);
   jint              jret = 0;

   if (qt->isUninitialized ())
   {
      CIMQualifierDecl *nqt = new CIMQualifierDecl (CIMName (str),CIMValue (),CIMScope ());

      jret = DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, nqt);
   }
   else
   {
      qt->setName (CIMName (str));

      CIMQualifierDecl *nqt = new CIMQualifierDecl (*qt);

      jret = DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, nqt);
   }

   jEnv->ReleaseStringUTFChars (jN,str);

   return jret;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifierType__1setValue
      (JNIEnv *jEnv, jobject jThs, jint jQ,jint jV)
{
   CIMQualifierDecl *qt = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ);
   CIMValue         *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);

   qt->setValue (*cv);
}

// -------------------------------------
// ---
// -     CIMQualifier
// ---
// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifier__1new
      (JNIEnv *jEnv, jobject jThs, jstring jN)
{
   const char   *str  = jEnv->GetStringUTFChars (jN,NULL);
   CIMQualifier *qual = new CIMQualifier (CIMName (str),CIMValue ());

   jEnv->ReleaseStringUTFChars (jN,str);

   return DEBUG_ConvertCToJava (CIMQualifier*, jint, qual);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1finalize
      (JNIEnv *jEnv, jobject jThs, jint jQ)
{
   CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);

   delete cq;

   DEBUG_ConvertCleanup (jint, jQ);
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getName
      (JNIEnv *jEnv, jobject jThs, jint jQ)
{
   CIMQualifier *cq  = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);
   const String &n   = cq->getName ().getString ();
   jstring       str = jEnv->NewStringUTF (n.getCString ());

   return str;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMQualifier__1getValue
      (JNIEnv *jEnv, jobject jThs, jint jQ)
{
   CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);
   CIMValue     *cv = new CIMValue (cq->getValue ());

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

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMQualifier__1setValue
      (JNIEnv *jEnv, jobject jThs, jint jQ,jint jV)
{
   CIMQualifier *cq = DEBUG_ConvertJavaToC (jint, CIMQualifier*, jQ);
   CIMValue     *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);

   cq->setValue (*cv);
}

// -------------------------------------
// ---
// -		CIMDateTime
// ---
// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetime
      (JNIEnv *jEnv, jobject jThs, jstring jN)
{
   const char  *str  = jEnv->GetStringUTFChars (jN, NULL);
   CIMDateTime *dt   = 0;
   String       date;

   if (  str
      && *str
      )
   {
      date = str;
   }

   jEnv->ReleaseStringUTFChars (jN, str);

   try
   {
      dt = new CIMDateTime (date);
   }
   Catch (jEnv);

   return DEBUG_ConvertCToJava (CIMDateTime*, jint, dt);
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMDateTime__1datetimeempty
      (JNIEnv *jEnv, jobject jThs)
{
   CIMDateTime *dt = new CIMDateTime (CIMDateTime::getCurrentDateTime ());

   return DEBUG_ConvertCToJava (CIMDateTime*, jint, dt);
}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1after
      (JNIEnv *jEnv, jobject jThs, jint jC, jint jD)
{
   CIMDateTime *ct = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jC);
   CIMDateTime *dt = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jD);
   jboolean     ret = 0;

   if (  ct
      && dt
      )
   {
      ret = (jboolean)(ct->getDifference (*ct, *dt)<0);
   }

   return ret;
}

JNIEXPORT jboolean JNICALL Java_org_pegasus_jmpi_CIMDateTime__1before
      (JNIEnv *jEnv, jobject jThs, jint jC, jint jD)
{
   CIMDateTime *ct  = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jC);
   CIMDateTime *dt  = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jD);
   jboolean     ret = 0;

   if (  ct
      && dt
      )
   {
      ret = (jboolean)(ct->getDifference (*ct, *dt)>0);
   }

   return ret;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMDateTime__1finalize
      (JNIEnv *jEnv, jobject jThs, jint jDT)
{
   CIMDateTime *cdt = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jDT);

   delete cdt;

   DEBUG_ConvertCleanup (jint, jDT);
}

// -------------------------------------
// ---
// -		CIMMethod
// ---
// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMMethod__1getType
      (JNIEnv *jEnv, jobject jThs, jint jM)
{
   CIMMethod *cm = DEBUG_ConvertJavaToC (jint, CIMMethod*, jM);

   return DEBUG_ConvertCToJava (CIMType *, jint, new CIMType (cm->getType ()));
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMMethod__1finalize
      (JNIEnv *jEnv, jobject jThs, jint jM)
{
   CIMMethod *cm = DEBUG_ConvertJavaToC (jint, CIMMethod*, jM);

   delete cm;

   DEBUG_ConvertCleanup (jint, jM);
}

// -------------------------------------
// ---
// -		CIMValue
// ---
// -------------------------------------


JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byte
      (JNIEnv *jEnv, jobject jThs, jbyte jb, jboolean notSigned)
{
   CIMValue *cv = NULL;

   if (notSigned)
      cv = new CIMValue ((Uint8)jb);
   else
      cv = new CIMValue ((Sint8)jb);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1short
      (JNIEnv *jEnv, jobject jThs, jshort js, jboolean notSigned)
{
   CIMValue *cv = NULL;

   if (notSigned)
      cv = new CIMValue ((Uint16)js);
   else
      cv = new CIMValue( (Sint16)js);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1makeInt
      (JNIEnv *jEnv, jobject jThs, jlong ji, jboolean notSigned)
{
   CIMValue *cv = NULL;

   if (notSigned)
      cv = new CIMValue ((Uint32)ji);
   else
      cv = new CIMValue ((Sint32)ji);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1long
      (JNIEnv *jEnv, jobject jThs, jlong jl, jboolean notSigned)
{
   CIMValue *cv = NULL;

   if (notSigned)
      cv = new CIMValue ((Uint64)jl);
   else
      cv = new CIMValue ((Sint64)jl);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1float
      (JNIEnv *jEnv, jobject jThs, jfloat jF)
{
   CIMValue *cv = new CIMValue (jF);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1double
      (JNIEnv *jEnv, jobject jThs, jdouble jD)
{
   CIMValue *cv = new CIMValue (jD);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1string
      (JNIEnv *jEnv, jobject jThs, jstring jS)
{
   const char *str = jEnv->GetStringUTFChars (jS,NULL);
   CIMValue   *cv  = new CIMValue (String (str));

   jEnv->ReleaseStringUTFChars (jS,str);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1cop
      (JNIEnv *jEnv, jobject jThs, jint jR)
{
   CIMObjectPath *ref = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jR);
   CIMValue      *cv  = new CIMValue (*ref);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1datetime
      (JNIEnv *jEnv, jobject jThs, jint jDT)
{
   CIMDateTime *dt = DEBUG_ConvertJavaToC (jint, CIMDateTime*, jDT);
   CIMValue    *cv = new CIMValue (*dt);

   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
      (JNIEnv *jEnv, jobject jThs, jint jP)
{
   CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jP);

   return (jboolean)cv->isArray ();
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1boolean
      (JNIEnv *jEnv, jobject jThs, jboolean jB)
{
   CIMValue *cv = new CIMValue ((Boolean)jB);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1byteArray
      (JNIEnv *jEnv, jobject jThs, jshortArray jshortA, jboolean notSigned)
{
   CIMValue *cv  = NULL;
   jboolean  b;
   jsize     len = jEnv->GetArrayLength (jshortA);
   jshort   *jsA = jEnv->GetShortArrayElements (jshortA,&b);

   if (notSigned)
   {
      Array<Uint8> u8;
      for (jsize i = 0; i < len; i++)
         u8.append ((Uint8)jsA[i]);
      cv = new CIMValue (u8);
   }
   else
   {
      Array<Sint8> s8;
      for (jsize i = 0; i < len; i++)
         s8.append ((Sint8)jsA[i]);
      cv = new CIMValue (s8);
   }

   jEnv->ReleaseShortArrayElements (jshortA, jsA, len);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1shortArray
      (JNIEnv *jEnv, jobject jThs, jintArray jintA, jboolean notSigned)
{
   CIMValue *cv  = NULL;
   jboolean  b;
   jsize     len = jEnv->GetArrayLength (jintA);
   jint     *jiA = jEnv->GetIntArrayElements (jintA,&b);

   if (notSigned)
   {
      Array<Uint16> u16;
      for (jsize i = 0; i < len; i++)
         u16.append ((Uint16)jiA[i]);
      cv = new CIMValue (u16);
   }
   else
   {
      Array<Sint16> s16;
      for (jsize i = 0; i < len; i++)
         s16.append ((Sint16)jiA[i]);
      cv = new CIMValue (s16);
   }

   jEnv->ReleaseIntArrayElements (jintA, jiA, len);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1intArray
      (JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned)
{
   CIMValue *cv  = NULL;
   jboolean  b;
   jsize     len = jEnv->GetArrayLength (jlongA);
   jlong    *jlA = jEnv->GetLongArrayElements (jlongA,&b);

   if (notSigned)
   {
      Array<Uint32> u32;
      for (jsize i = 0; i < len; i++)
         u32.append ((Uint32)jlA[i]);
      cv = new CIMValue (u32);
   }
   else
   {
      Array<Sint32> s32;
      for (jsize i = 0; i < len; i++)
         s32.append ((Sint32)jlA[i]);
      cv = new CIMValue (s32);
   }

   jEnv->ReleaseLongArrayElements (jlongA, jlA, len);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1longArray
      (JNIEnv *jEnv, jobject jThs, jlongArray jlongA, jboolean notSigned)
{
   CIMValue *cv  = NULL;
   jboolean  b;
   jsize     len = jEnv->GetArrayLength (jlongA);
   jlong    *jlA = jEnv->GetLongArrayElements (jlongA,&b);

   if (notSigned)
   {
      Array<Uint64> u64;
      for (jsize i = 0; i < len; i++)
         u64.append ((Uint64)jlA[i]);
      cv = new CIMValue (u64);
   }
   else
   {
      Array<Sint64> s64;
      for (jsize i = 0; i < len; i++)
         s64.append ((Sint64)jlA[i]);
      cv = new CIMValue (s64);
   }

   jEnv->ReleaseLongArrayElements (jlongA, jlA, len);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1stringArray
      (JNIEnv *jEnv, jobject jThs, jobjectArray jstringA)
{
   CIMValue     *cv   = NULL;
   jsize         len  = jEnv->GetArrayLength (jstringA);
   Array<String> strA;

   for (jsize i = 0;i < len; i++)
   {
      jstring     jsA = (jstring)jEnv->GetObjectArrayElement (jstringA,i);
      const char *str = jEnv->GetStringUTFChars (jsA,NULL);

      strA.append (String (str));

      jEnv->ReleaseStringUTFChars (jsA,str);
   }

   cv = new CIMValue (strA);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1booleanArray
      (JNIEnv *jEnv, jobject jThs, jbooleanArray jboolA)
{
   CIMValue       *cv  = NULL;
   jboolean        b;
   jsize           len = jEnv->GetArrayLength (jboolA);
   jboolean       *jbA = jEnv->GetBooleanArrayElements (jboolA,&b);
   Array<Boolean>  bA;

   for (jsize i = 0; i < len; i++)
      bA.append ((Boolean)jbA[i]);
   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);
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1copArray
      (JNIEnv *jEnv, jobject jThs, jintArray jintA)
{
   CIMValue             *cv  = NULL;
   jboolean              b;
   jsize                 len = jEnv->GetArrayLength (jintA);
   jint                 *jiA = jEnv->GetIntArrayElements (jintA,&b);
   Array<CIMObjectPath>  cA;

   for (jsize i = 0; i < len; i++)
      cA.append (*((CIMObjectPath*)jiA[i]));
   cv = new CIMValue (cA);

   jEnv->ReleaseIntArrayElements (jintA, jiA, len);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1datetimeArray
      (JNIEnv *jEnv, jobject jThs, jintArray jintA)
{
   CIMValue           *cv  = NULL;
   jboolean            b;
   jsize               len = jEnv->GetArrayLength (jintA);
   jint               *jiA = jEnv->GetIntArrayElements (jintA,&b);
   Array<CIMDateTime>  cA;

   for (jsize i = 0; i < len; i++)
      cA.append (*((CIMDateTime*)jiA[i]));
   cv = new CIMValue (cA);

   jEnv->ReleaseIntArrayElements (jintA, jiA, len);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1objectArray
      (JNIEnv *jEnv, jobject jThs, jintArray jintA)
{
   CIMValue           *cv  = NULL;
   jboolean            b;
   jsize               len = jEnv->GetArrayLength (jintA);
   jint               *jiA = jEnv->GetIntArrayElements (jintA,&b);
   Array<CIMObject>    cA;

   for (jsize i = 0; i < len; i++)
      cA.append (*((CIMObject*)jiA[i]));
   cv = new CIMValue (cA);

   jEnv->ReleaseIntArrayElements (jintA, jiA, len);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1char16Array
      (JNIEnv *jEnv, jobject jThs, jcharArray jcharA)
{
   CIMValue      *cv  = NULL;
   jboolean       b;
   jsize          len = jEnv->GetArrayLength (jcharA);
   jchar         *jcA = jEnv->GetCharArrayElements (jcharA,&b);
   Array<Char16>  cA;

   for (jsize i = 0; i < len; i++)
      cA.append (Char16 (jcA[i]));
   cv = new CIMValue (cA);

   jEnv->ReleaseCharArrayElements (jcharA, jcA, len);

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMValue__1getType
      (JNIEnv *jEnv, jobject jThs, jint jP)
{
   CIMValue *cv       = DEBUG_ConvertJavaToC (jint, CIMValue*, jP);
   bool      fSuccess = false;
   int       iJType   = 0;

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

   return DEBUG_ConvertCToJava (int, jint, iJType);
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMValue__1toString
      (JNIEnv *jEnv, jobject jThs, jint jV)
{
   CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);

   return (jstring)jEnv->NewStringUTF (cv->toString ().getCString ());
}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMValue__1getValue
      (JNIEnv *jEnv, jobject jThs, jint jV)
{
   JMPIjvm::cacheIDs (jEnv);

   CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);

   if (cv->isNull ())
      return NULL;

   CIMType type = cv->getType ();

   if (!cv->isArray ())
   {
      switch (type)
      {
      case CIMTYPE_BOOLEAN:
         Boolean bo;
         cv->get (bo);
         return jEnv->NewObject (JMPIjvm::jv.BooleanClassRef,
                                 JMPIjvm::jv.BooleanNewZ,
                                 bo);
      case CIMTYPE_SINT8:
         Sint8 s8;
         cv->get (s8);
         return jEnv->NewObject (JMPIjvm::jv.ByteClassRef,
                                 JMPIjvm::jv.ByteNewB,
                                 s8);
      case CIMTYPE_UINT8:
         Uint8 u8;
         cv->get (u8);
         return jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef,
                                 JMPIjvm::jv.UnsignedInt8NewS,
                                 u8);
      case CIMTYPE_SINT16:
         Sint16 s16;
         cv->get (s16);
         return jEnv->NewObject (JMPIjvm::jv.ShortClassRef,
                                 JMPIjvm::jv.ShortNewS,
                                 s16);
      case CIMTYPE_UINT16:
         Uint16 u16;
         cv->get (u16);
         return jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef,
                                 JMPIjvm::jv.UnsignedInt16NewI,
                                 u16);
      case CIMTYPE_SINT32:
         Sint32 s32;
         cv->get (s32);
         return jEnv->NewObject (JMPIjvm::jv.IntegerClassRef,
                                 JMPIjvm::jv.IntegerNewI,
                                 s32);
      case CIMTYPE_UINT32:
         Uint32 u32;
         cv->get (u32);
         return jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef,
                                 JMPIjvm::jv.UnsignedInt32NewJ,
                                 u32);
      case CIMTYPE_SINT64:
         Sint64 s64;
         cv->get (s64);
         return jEnv->NewObject (JMPIjvm::jv.LongClassRef,
                                 JMPIjvm::jv.LongNewJ,
                                 s64);
      case CIMTYPE_UINT64:
      {
         Uint64 u64;
         cv->get (u64);
         jobject jBIG = jEnv->CallStaticObjectMethod (JMPIjvm::jv.BigIntegerClassRef,
                                                      JMPIjvm::jv.BigIntegerValueOf,
                                                      u64);
         return jEnv->NewObject (JMPIjvm::jv.UnsignedInt64ClassRef,
                                 JMPIjvm::jv.UnsignedInt64NewBi,
                                 jBIG);
      }
      case CIMTYPE_REAL32:
         float f;
         cv->get (f);
         return jEnv->NewObject (JMPIjvm::jv.FloatClassRef,
                                 JMPIjvm::jv.FloatNewF,
                                 f);
      case CIMTYPE_REAL64:
         double d;
         cv->get (d);
         return jEnv->NewObject (JMPIjvm::jv.DoubleClassRef,
                                 JMPIjvm::jv.DoubleNewD,
                                 d);
      case CIMTYPE_STRING:
      {
         String s;
         cv->get (s);
         return jEnv->NewStringUTF (s.getCString ());
      }
      case CIMTYPE_REFERENCE:
      {
         CIMObjectPath ref;
         cv->get (ref);
         jint jOp = DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath (ref));
         return jEnv->NewObject (JMPIjvm::jv.CIMObjectPathClassRef,
                                 JMPIjvm::jv.CIMObjectPathNewI,
                                 jOp);
      }
      case CIMTYPE_CHAR16:
      {
         Char16 c16;
         cv->get (c16);
         return jEnv->NewObject (JMPIjvm::jv.CharacterClassRef,
                                 JMPIjvm::jv.CharacterNewC,
                                 (jchar)c16);
      }
      case CIMTYPE_DATETIME:
      {
         CIMDateTime dt;
         cv->get (dt);
         jint jDT = DEBUG_ConvertCToJava (CIMDateTime*, jint, new CIMDateTime (dt));
         return jEnv->NewObject (JMPIjvm::jv.CIMDateTimeClassRef,
                                 JMPIjvm::jv.CIMDateTimeNewI,
                                 jDT);
      }
      case CIMTYPE_OBJECT:
      {
         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:
         throwCIMException (jEnv,"+++ unsupported type: ");
      }
   }
   else
   {
      switch (type)
      {
      case CIMTYPE_BOOLEAN:
      {
         Array<Boolean> bo;

         cv->get (bo);

         int          s         = bo.size ();
         jobjectArray jbooleanA = (jobjectArray)jEnv->NewObjectArray (s,
                                                                      JMPIjvm::jv.BooleanClassRef,
                                                                      0);

         for (int i = 0; i < s; i++)
            jEnv->SetObjectArrayElement (jbooleanA,
                                        i,
                                        jEnv->NewObject (JMPIjvm::jv.BooleanClassRef,
                                                         JMPIjvm::jv.BooleanNewZ,
                                                         bo[i]));
         return jbooleanA;
      }
      case CIMTYPE_SINT8:
      {
         Array<Sint8> s8;

         cv->get (s8);

         int          s      = s8.size ();
         jobjectArray jbyteA = (jobjectArray)jEnv->NewObjectArray (s,
                                                                   JMPIjvm::jv.ByteClassRef,
                                                                   0);

         for (int i = 0; i < s; i++)
            jEnv->SetObjectArrayElement (jbyteA,
                                         i,
                                         jEnv->NewObject (JMPIjvm::jv.ByteClassRef,
                                                          JMPIjvm::jv.ByteNewB,
                                                          s8[i]));
         return jbyteA;
      }
      case CIMTYPE_UINT8:
      {
         Array<Uint8> u8;

         cv->get (u8);

         int          s       = u8.size ();
         jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray (s,
                                                                    JMPIjvm::jv.UnsignedInt8ClassRef,
                                                                    0);
         for (int i = 0; i < s; i++)
            jEnv->SetObjectArrayElement (jshortA,
                                         i,
                                         jEnv->NewObject (JMPIjvm::jv.UnsignedInt8ClassRef,
                                                          JMPIjvm::jv.UnsignedInt8NewS,
                                                          u8[i]));
         return jshortA;
      }
      case CIMTYPE_SINT16:
      {
         Array<Sint16> s16;

         cv->get (s16);

         int          s       = s16.size ();
         jobjectArray jshortA = (jobjectArray)jEnv->NewObjectArray (s,
                                                                    JMPIjvm::jv.ShortClassRef,
                                                                    0);

         for (int i = 0; i < s; i++)
            jEnv->SetObjectArrayElement (jshortA,
                                         i,
                                         jEnv->NewObject (JMPIjvm::jv.ShortClassRef,
                                                          JMPIjvm::jv.ShortNewS,
                                                          s16[i]));
         return jshortA;
      }
      case CIMTYPE_UINT16:
      {
         Array<Uint16> u16;

         cv->get (u16);

         int          s     = u16.size ();
         jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray (s,
                                                                  JMPIjvm::jv.UnsignedInt16ClassRef,
                                                                  0);

         for (int i = 0; i < s; i++)
            jEnv->SetObjectArrayElement (jintA,
                                         i,
                                         jEnv->NewObject (JMPIjvm::jv.UnsignedInt16ClassRef,
                                                          JMPIjvm::jv.UnsignedInt16NewI,
                                                          u16[i]));
         return jintA;
      }
      case CIMTYPE_SINT32:
      {
         Array<Sint32> s32;

         cv->get (s32);

         int          s     = s32.size ();
         jobjectArray jintA = (jobjectArray)jEnv->NewObjectArray (s,
                                                                  JMPIjvm::jv.IntegerClassRef,
                                                                  0);

         for (int i = 0; i < s; i++)
            jEnv->SetObjectArrayElement (jintA,
                                         i,
                                         jEnv->NewObject (JMPIjvm::jv.IntegerClassRef,
                                                          JMPIjvm::jv.IntegerNewI,
                                                          s32[i]));
         return jintA;
      }
      case CIMTYPE_UINT32:
      {
         Array<Uint32> u32;

         cv->get (u32);

         int          s      = u32.size ();
         jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray (s,
                                                                   JMPIjvm::jv.UnsignedInt32ClassRef,
                                                                   0);

         for (int i = 0; i < s; i++)
            jEnv->SetObjectArrayElement (jlongA,
                                         i,
                                         jEnv->NewObject (JMPIjvm::jv.UnsignedInt32ClassRef,
                                                          JMPIjvm::jv.UnsignedInt32NewJ,
                                                          u32[i]));
         return jlongA;
      }
      case CIMTYPE_SINT64:
      {
         Array<Sint64> s64;

         cv->get (s64);

         int          s      = s64.size ();
         jobjectArray jlongA = (jobjectArray)jEnv->NewObjectArray (s,
                                                                   JMPIjvm::jv.LongClassRef,
                                                                   0);

         for (int i = 0; i < s; i++)
            jEnv->SetObjectArrayElement (jlongA,
                                         i,
                                         jEnv->NewObject (JMPIjvm::jv.LongClassRef,
                                                          JMPIjvm::jv.LongNewJ,
                                                          s64[i]));
         return jlongA;
      }
      case CIMTYPE_UINT64:
      {
         Array<Uint64> u64;

         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;

         cv->get (r32);

         int          s       = r32.size ();
         jobjectArray jfloatA = (jobjectArray)jEnv->NewObjectArray (s,
                                                                    JMPIjvm::jv.FloatClassRef,
                                                                    0);

         for (int i = 0; i < s; i++)
            jEnv->SetObjectArrayElement (jfloatA,
                                         i,
                                         jEnv->NewObject (JMPIjvm::jv.FloatClassRef,
                                                          JMPIjvm::jv.FloatNewF,
                                                          r32[i]));
         return jfloatA;
      }
      case CIMTYPE_REAL64:
      {
         Array<Real64> r64;

         cv->get (r64);

         int          s        = r64.size ();
         jobjectArray jdoubleA = (jobjectArray)jEnv->NewObjectArray (s,
                                                                     JMPIjvm::jv.DoubleClassRef,
                                                                     0);

         for (int i = 0; i < s; i++)
            jEnv->SetObjectArrayElement (jdoubleA,
                                         i,
                                         jEnv->NewObject (JMPIjvm::jv.DoubleClassRef,
                                                          JMPIjvm::jv.DoubleNewD,
                                                          r64[i]));
         return jdoubleA;
      }
      case CIMTYPE_STRING:
      {
         Array<String> str;

         cv->get (str);

         int          s        = str.size ();
         jobjectArray jstringA = (jobjectArray)jEnv->NewObjectArray (s,
                                                                     JMPIjvm::jv.StringClassRef,
                                                                     0);

         for (int i = 0; i < s; i++)
            jEnv->SetObjectArrayElement (jstringA,
                                         i,
                                         jEnv->NewStringUTF (str[i].getCString ()));
         return jstringA;
      }
      case CIMTYPE_REFERENCE:
      {
         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:
      {
         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:
      {
         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:
      {
         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:
         throwCIMException (jEnv,"+++ unsupported type: ");
      }
   }

   return NULL;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMValue__1finalize
      (JNIEnv *jEnv, jobject jThs, jint jV)
{
   CIMValue *cv = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);

   delete cv;

   DEBUG_ConvertCleanup (jint, jV);
}

// -------------------------------------
// ---
// -		CIMNameSpace
// ---
// -------------------------------------

_nameSpace::_nameSpace ()
{
   port_ = 0;
   hostName_ = System::getHostName ();
   nameSpace_ = "root/cimv2";
}

_nameSpace::_nameSpace (String hn)
{
   port_ = 0;
   hostName_ = hn;
   nameSpace_ = "root/cimv2";
}

_nameSpace::_nameSpace (String hn, String ns)
{
    port_ = 0;
    hostName_ = hn;
    nameSpace_ = ns;
}

int _nameSpace::port ()
{
   if (port_)
      return port_;
   port_ = 5988;
   if (hostName_.subString (0,7) == "http://")
   {
      protocol_ = "http://";
      hostName_ = hostName_.subString (7);
   }
   Sint32 p = hostName_.reverseFind (':');
   if (p>= 0)
   {
      if ((hostName_[p+1] >= '0') && (hostName_[p+1] <= '9'))
         port_ = atoi (hostName_.subString (p+1).getCString ());
      hostName_.remove (p);
   }
   return port_;
}

String _nameSpace::hostName ()
{
   port ();
   return hostName_;
}

String _nameSpace::nameSpace ()
{
   return nameSpace_;
}


JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1new
  (JNIEnv *jEnv, jobject jThs)
{
  return DEBUG_ConvertCToJava (_nameSpace*, jint, new _nameSpace ());
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHn
  (JNIEnv *jEnv, jobject jThs, jstring jHn)
{
   const char *hn    = jEnv->GetStringUTFChars (jHn,NULL);
   jint        cInst = DEBUG_ConvertCToJava (_nameSpace*, jint, new _nameSpace (hn));

   jEnv->ReleaseStringUTFChars (jHn,hn);

   return cInst;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1newHnNs
  (JNIEnv *jEnv, jobject jThs, jstring jHn, jstring jNs)
{
   const char *hn    = jEnv->GetStringUTFChars (jHn,NULL);
   const char *ns    = jEnv->GetStringUTFChars (jNs,NULL);
   jint        cInst = DEBUG_ConvertCToJava (_nameSpace*, jint, new _nameSpace (String (hn),String (ns)));

   jEnv->ReleaseStringUTFChars (jHn,hn);
   jEnv->ReleaseStringUTFChars (jNs,ns);

   return cInst;
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getHost
  (JNIEnv *jEnv, jobject jThs, jint jNs)
{
   _nameSpace   *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);
   const String &hn  = cNs->hostName_;
   jstring       str = jEnv->NewStringUTF (hn.getCString ());

   return str;
}

JNIEXPORT jstring JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1getNameSpace
  (JNIEnv *jEnv, jobject jThs, jint jNs)
{
   _nameSpace   *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);
   const String &ns  = cNs->nameSpace_;
   jstring       str = jEnv->NewStringUTF (ns.getCString ());

   return str;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setHost
  (JNIEnv *jEnv, jobject jThs, jint jNs, jstring jHn)
{
   _nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);
   const char *str = jEnv->GetStringUTFChars (jHn,NULL);

   cNs->port_ = 0;
   cNs->hostName_ = str;

   jEnv->ReleaseStringUTFChars (jHn,str);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1setNameSpace
  (JNIEnv *jEnv, jobject jThs, jint jNs, jstring jN)
{
   _nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);
   const char *str = jEnv->GetStringUTFChars (jN,NULL);

   cNs->nameSpace_ = str;

   jEnv->ReleaseStringUTFChars (jN,str);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMNameSpace__1finalize
   (JNIEnv *jEnv, jobject jThs, jint jNs)
{
   _nameSpace *cNs = DEBUG_ConvertJavaToC (jint, _nameSpace*, jNs);

   delete cNs;

   DEBUG_ConvertCleanup (jint, jNs);
}

// -------------------------------------
// ---
// -		Enumerators
// ---
// -------------------------------------

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1getClass
  (JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)
{
   Array<CIMClass> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMClass>*, jEnum);

   return DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass ((*enm)[pos]));
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_ClassEnumeration__1size
  (JNIEnv *jEnv, jobject jThs, jint jEnum)
{
   Array<CIMClass> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMClass>*, jEnum);

   return enm->size ();
}


JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1getInstance
  (JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)
{
   Array<CIMInstance> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMInstance>*, jEnum);

   return DEBUG_ConvertCToJava (CIMInstance*, jint, new CIMInstance ((*enm)[pos]));
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_InstEnumeration__1size
  (JNIEnv *jEnv, jobject jThs, jint jEnum)
{
   Array<CIMInstance> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMInstance>*, jEnum);

   return enm->size ();
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1getObjectPath
  (JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)
{
   Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMObjectPath>*, jEnum);

   return DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath ((*enm)[pos]));
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_PathEnumeration__1size
  (JNIEnv *jEnv, jobject jThs, jint jEnum)
{
   Array<CIMObjectPath> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMObjectPath>*, jEnum);

   return enm->size ();
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1getQualifierType
  (JNIEnv *jEnv, jobject jThs, jint jEnum, jint pos)
{
   Array<CIMQualifierDecl> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMQualifierDecl>*, jEnum);

   return DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, new CIMQualifierDecl ((*enm)[pos]));
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_QualEnumeration__1size
  (JNIEnv *jEnv, jobject jThs, jint jEnum)
{
   Array<CIMQualifierDecl> *enm = DEBUG_ConvertJavaToC (jint, Array<CIMQualifierDecl>*, jEnum);

   return enm->size ();
}

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

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

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

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

   try {
      CIMClient *cc = new CIMClient ();

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

      jCc = DEBUG_ConvertCToJava (CIMClient*, jint, 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, jint jCc)
{
   CIMClient *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);

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

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

   try {
      checkNs (cop,jNs);
      CIMClass cls = cCc->getClass (cop->getNameSpace (),cop->getClassName (), (Boolean)lo,
                (Boolean)iq, (Boolean)ic,pl);
      return DEBUG_ConvertCToJava (CIMClass*, jint, new CIMClass (cls));
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteClass
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop)
{
   CIMClient     *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, 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, jint jCc, jint jNs, jint jCop, int jCl)
{
   CIMClient     *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   CIMClass      *cl  = DEBUG_ConvertJavaToC (jint, CIMClass*, jCl);

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

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

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

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClasses
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, int jCop, jboolean deep, jboolean lo, jboolean iq, jboolean ic)
{
   CIMClient     *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

   try {
      checkNs (cop,jNs);
      Array<CIMClass> enm = cCc->enumerateClasses(
         cop->getNameSpace (),cop->getClassName (), (Boolean)deep, (Boolean)lo, (Boolean)iq, (Boolean)ic);
      return DEBUG_ConvertCToJava (Array<CIMClass>*, jint, new Array<CIMClass> (enm));
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateClassNames
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep)
{
   CIMClient        *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   CIMNamespaceName  ns  = cop->getNameSpace ();

   try {
      checkNs (cop,jNs);
      Array<CIMName> enm = cCc->enumerateClassNames (ns,cop->getClassName (), (Boolean)deep);
      Array<CIMObjectPath> *enmop = new Array<CIMObjectPath> ();
      for (int i = 0,m = enm.size (); i<m; i++)
      {
         enmop->append (CIMObjectPath (String::EMPTY,ns,enm[i]));
      }
      return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, enmop);
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateQualifiers
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, int jCop)
{
   CIMClient     *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

   try {
      checkNs (cop,jNs);

      Array<CIMQualifierDecl> enm = cCc->enumerateQualifiers (cop->getNameSpace ());

      return DEBUG_ConvertCToJava (Array<CIMQualifierDecl>*, jint, new Array<CIMQualifierDecl> (enm));
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getInstance
  (JNIEnv *jEnv, jobject jThs, jint jCc, int jNs, int jCop, jboolean lo,
         jboolean iq, jboolean ic, jobjectArray jPl)
{
   CIMClient        *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, 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);

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

   return 0;
}

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

   try {
      checkNs (cop,jNs);
      cCc->deleteInstance (cop->getNameSpace (),*cop);
   }
   Catch (jEnv);
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1createInstance
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, int jCi)
{
   CIMClient     *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   CIMInstance   *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);

   try {
      checkNs (cop,jNs);
      ci->setPath (*cop);
      CIMObjectPath obj = cCc->createInstance (cop->getNameSpace (),*ci);
      return DEBUG_ConvertCToJava (CIMObjectPath*, jint, new CIMObjectPath (obj));
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1modifyInstance
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jCi,
         jboolean iq, jobjectArray jPl)
{
   CIMClient       *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath   *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   CIMInstance     *ci  = DEBUG_ConvertJavaToC (jint, CIMInstance*, jCi);
   CIMPropertyList  pl  = getList (jEnv,jPl);

   try {
      checkNs (cop,jNs);
      ci->setPath (*cop);
      cCc->modifyInstance (cop->getNameSpace (),*ci, (Boolean)iq,pl);
   }
   Catch (jEnv);
}

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

   try {
      checkNs (cop,jNs);
      CIMPropertyList props;
      Array<CIMInstance> enm = cCc->enumerateInstances(
         cop->getNameSpace (),cop->getClassName (), (Boolean)deep, (Boolean)lo, (Boolean)iq, (Boolean)ic,pl);
      return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, new Array<CIMInstance> (enm));
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateInstanceNames
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jboolean deep)
{
   CIMClient     *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);

   try {
      checkNs (cop,jNs);
      Array<CIMObjectPath> enm = cCc->enumerateInstanceNames(
         cop->getNameSpace (),cop->getClassName ()); //, (Boolean)deep);
      return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath> (enm));
   }
   Catch (jEnv);

   return 0;
}


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

   try {
      checkNs (cop,jNs);
      CIMQualifierDecl *val = new CIMQualifierDecl (cCc->getQualifier (cop->getNameSpace (),cop->getClassName ()));
      return DEBUG_ConvertCToJava (CIMQualifierDecl*, jint, val);
   }
   Catch (jEnv);

   return 0;
}

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

   try {
      checkNs (cop,jNs);
      cCc->deleteQualifier (cop->getNameSpace (),cop->getClassName ());
   }
   Catch (jEnv);
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setQualifier
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jint jQ)
{
   CIMClient        *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath    *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   CIMQualifierDecl *qt  = DEBUG_ConvertJavaToC (jint, CIMQualifierDecl*, jQ);

   try {
      checkNs (cop,jNs);
      cCc->setQualifier (cop->getNameSpace (),*qt);
   }
   Catch (jEnv);
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1getProperty
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn)
{
   CIMClient     *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   const char    *str = jEnv->GetStringUTFChars (jPn,NULL);
   CIMName        pName (str);
   jint           jCv = 0;

   try {
      checkNs (cop,jNs);

      CIMValue *val = new CIMValue (cCc->getProperty (cop->getNameSpace (),*cop,pName));

      jCv = DEBUG_ConvertCToJava (CIMValue*, jint, val);
   }
   Catch (jEnv);

   jEnv->ReleaseStringUTFChars (jPn,str);

   return jCv;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1setProperty
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jPn, jint jV)
{
   CIMClient     *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   CIMValue      *val = DEBUG_ConvertJavaToC (jint, CIMValue*, jV);
   const char    *str = jEnv->GetStringUTFChars (jPn,NULL);
   CIMName        pName (str);

   try {
      checkNs (cop,jNs);
      cCc->setProperty (cop->getNameSpace (),*cop,pName,*val);
   }
   Catch (jEnv);

   jEnv->ReleaseStringUTFChars (jPn,str);
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn, jobject jIn, jobject jOut)
{
   JMPIjvm::cacheIDs (jEnv);

   CIMClient            *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath        *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   const char           *str = jEnv->GetStringUTFChars (jMn,NULL);
   CIMName               method (str);
   jint                  jCv = 0;
   Array<CIMParamValue>  in;
   Array<CIMParamValue>  out;

   for (int i = 0,m = jEnv->CallIntMethod (jIn,JMPIjvm::jv.VectorSize); i<m; i++)
   {
       JMPIjvm::checkException (jEnv);

       jobject jProp = jEnv->CallObjectMethod (jIn,JMPIjvm::jv.VectorElementAt,i);
       JMPIjvm::checkException (jEnv);

       jint         jp = jEnv->CallIntMethod (jProp,JMPIjvm::jv.CIMPropertyCInst);
       CIMProperty *p  = DEBUG_ConvertJavaToC (jint, CIMProperty*, jp);

       JMPIjvm::checkException (jEnv);

       in.append (CIMParamValue (p->getName ().getString (),p->getValue ()));
   }

   try {
      checkNs (cop,jNs);

      CIMValue *val = new CIMValue (cCc->invokeMethod (cop->getNameSpace (),*cop,method,in,out));

      for (int i = 0,m = out.size (); i<m; i++)
      {
         const CIMParamValue &parm = out[i];
         const CIMValue       v    = parm.getValue ();
         CIMProperty         *p    = new CIMProperty (parm.getParameterName (),v,v.getArraySize ());
         jint                 jp   = DEBUG_ConvertCToJava (CIMProperty*, jint, p);
         jobject              prop = jEnv->NewObject (JMPIjvm::jv.CIMPropertyClassRef,JMPIjvm::jv.CIMPropertyNewI,jp);

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

      jCv = DEBUG_ConvertCToJava (CIMValue*, jint, val);
   }
   Catch (jEnv);

   jEnv->ReleaseStringUTFChars (jMn,str);

   return jCv;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1invokeMethod24
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jMn,
        jobjectArray jIn, jobjectArray jOut)
{
   JMPIjvm::cacheIDs (jEnv);

   CIMClient            *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath        *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   const char           *str = jEnv->GetStringUTFChars (jMn,NULL);
   CIMName               method (str);
   jint                  jCv = 0;
   Array<CIMParamValue> in;
   Array<CIMParamValue> out;

   if (jIn)
   {
      for (int i = 0,m = jEnv->GetArrayLength (jIn); i<m; i++)
      {
          JMPIjvm::checkException (jEnv);

          jobject jArg = jEnv->GetObjectArrayElement (jIn,i);
          JMPIjvm::checkException (jEnv);

          jint           jp = jEnv->CallIntMethod (jArg,JMPIjvm::jv.CIMArgumentCInst);
          CIMParamValue *p  = DEBUG_ConvertJavaToC (jint, CIMParamValue*, jp);

          JMPIjvm::checkException (jEnv);

          in.append (*p);
      }
   }
   try {
      checkNs (cop,jNs);
      CIMValue *val = new CIMValue (cCc->invokeMethod (cop->getNameSpace (),*cop,method,in,out));

      if (jOut)
      {
         for (int i = 0,m = out.size (),o = jEnv->GetArrayLength (jOut); i<m && i<o; i++)
         {
            CIMParamValue *parm  = new CIMParamValue (out[i]);
            jint           jParm = DEBUG_ConvertCToJava (CIMParamValue*, jint, parm);

            jEnv->SetObjectArrayElement (jOut,
                                        i,
                                        jEnv->NewObject (JMPIjvm::jv.CIMArgumentClassRef,JMPIjvm::jv.CIMArgumentNewI,jParm));
         }
      }
      jCv = DEBUG_ConvertCToJava (CIMValue*, jint, val);
   }
   Catch (jEnv);

   jEnv->ReleaseStringUTFChars (jMn,str);

   return jCv;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1execQuery
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop, jstring jQuery, jstring jQl)
{
   CIMClient     *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   const char    *str = jEnv->GetStringUTFChars (jQuery,NULL);
   String         query (str);

/* @NOTE
** This does not work for some reason on the client java code:
**   DDD (PEGASUS_STD (cout)<<"--- JMPIjvm::Java_org_pegasus_jmpi_CIMClient__1execQuery: jEnv = "<<PEGASUS_STD (hex)<< (int)jEnv<<", jThs = "<< (int)jThs<<PEGASUS_STD (dec)<<", jCc = "<<jCc<<", jNs = "<<jNs<<", jCop = "<<jCop<<", jQuery = "<<PEGASUS_STD (hex)<< (int)jQuery<<", jQl = "<< (int)jQl<<PEGASUS_STD (dec)<<PEGASUS_STD (endl));
** What does work is:
**   printf ("This is a test\n");
**
** To debug these JNI functions insert the following:
**    if (getenv ("PEGASUS_JMPI_GDB"))
**    {
**       bool fLoop = true;
**       int  i     = 0;
**
**       while (fLoop)
**       {
**          i = 1;
**       }
**    }
** Export the variable PEGASUS_JMPI_GDB = 1.
** Start gdb in another process.
**    shell ps -efl
**    att <ps number>
**    set fLoop = 0
*/

   jEnv->ReleaseStringUTFChars (jQuery,str);

   str = jEnv->GetStringUTFChars (jQl,NULL);

   String ql (str);

   jEnv->ReleaseStringUTFChars (jQl,str);

   try {
      checkNs (cop,jNs);
      Array<CIMObject> enm = cCc->execQuery (cop->getNameSpace (),ql,query);
      Array<CIMInstance> *enmInst = new Array<CIMInstance> ();
      for (int i = 0,m = enm.size (); i<m; i++)
      {
         enmInst->append (CIMInstance (enm[i]));
      }
      return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associatorNames
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,
   jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole)
{
   CIMClient     *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   const char    *str = jEnv->GetStringUTFChars (jAssocClass, NULL);

   CIMName assocClass;

   if (  str
      && *str
      )
   {
      if (CIMName::legal (str))
      {
         assocClass = str;
      }
      else
      {
         jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
                                       JMPIjvm::jv.CIMExceptionNewISt,
                                       (jint)4, // CIM_ERR_INVALID_PARAMETER
                                       jEnv->NewStringUTF ("Invalid association class name"));

         jEnv->Throw ((jthrowable)ev);

         return 0;
      }
   }

   jEnv->ReleaseStringUTFChars (jAssocClass,str);

   str = jEnv->GetStringUTFChars (jResultClass, NULL);

   CIMName resultClass;

   if (  str
      && *str
      )
   {
      if (CIMName::legal (str))
      {
         resultClass = str;
      }
      else
      {
         jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
                                       JMPIjvm::jv.CIMExceptionNewISt,
                                       (jint)4, // CIM_ERR_INVALID_PARAMETER
                                       jEnv->NewStringUTF ("Invalid result class name"));

         jEnv->Throw ((jthrowable)ev);

         return 0;
      }
   }

   jEnv->ReleaseStringUTFChars (jResultClass, str);

   str = jEnv->GetStringUTFChars (jRole, NULL);

   String role (str);

   jEnv->ReleaseStringUTFChars (jRole, str);

   str = jEnv->GetStringUTFChars (jResultRole, NULL);

   String resultRole (str);

   jEnv->ReleaseStringUTFChars (jResultRole, str);

   try {
      checkNs (cop,jNs);

      Array<CIMObjectPath> enm = cCc->associatorNames (cop->getNameSpace (),
                                                      *cop,
                                                      assocClass,
                                                      resultClass,
                                                      role,
                                                      resultRole);
      return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath> (enm));
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1associators
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,
   jstring jAssocClass, jstring jResultClass, jstring jRole, jstring jResultRole,
   jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)
{
   CIMClient       *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath   *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   CIMPropertyList  pl  = getList (jEnv, jPl);
   const char      *str = jEnv->GetStringUTFChars (jAssocClass, NULL);

   CIMName assocClass;

   if (  str
      && *str
      )
   {
      if (CIMName::legal (str))
      {
         assocClass = str;
      }
      else
      {
         jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
                                       JMPIjvm::jv.CIMExceptionNewISt,
                                       (jint)4, // CIM_ERR_INVALID_PARAMETER
                                       jEnv->NewStringUTF ("Invalid association class name"));

         jEnv->Throw ((jthrowable)ev);

         return 0;
      }
   }

   jEnv->ReleaseStringUTFChars (jAssocClass, str);

   str = jEnv->GetStringUTFChars (jResultClass, NULL);

   CIMName resultClass;

   if (  str
      && *str
      )
   {
      if (CIMName::legal (str))
      {
         resultClass = str;
      }
      else
      {
         jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
                                       JMPIjvm::jv.CIMExceptionNewISt,
                                       (jint)4, // CIM_ERR_INVALID_PARAMETER
                                       jEnv->NewStringUTF ("Invalid result class name"));

         jEnv->Throw ((jthrowable)ev);

         return 0;
      }
   }

   jEnv->ReleaseStringUTFChars (jResultClass, str);

   str = jEnv->GetStringUTFChars (jRole, NULL);

   String role (str);

   jEnv->ReleaseStringUTFChars (jRole, str);

   str = jEnv->GetStringUTFChars (jResultRole, NULL);

   String resultRole (str);

   jEnv->ReleaseStringUTFChars (jResultRole, str);

   try {
      checkNs (cop, jNs);

      Array<CIMObject> enm = cCc->associators (cop->getNameSpace (),
                                               *cop,
                                               assocClass,
                                               resultClass,
                                               role,
                                               resultRole,
                                               (Boolean)includeQualifiers,
                                               (Boolean)includeClassOrigin,
                                               pl);
      Array<CIMInstance> *enmInst = new Array<CIMInstance> ();

      for (int i = 0,m = enm.size (); i<m; i++)
      {
         enmInst->append (CIMInstance (enm[i]));
      }

      return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1referenceNames
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,
   jstring jAssocClass, jstring jRole)
{
   CIMClient     *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   const char    *str = jEnv->GetStringUTFChars (jAssocClass, NULL);

   CIMName assocClass;

   if (  str
      && *str
      )
   {
      if (CIMName::legal (str))
      {
         assocClass = str;
      }
      else
      {
         jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
                                       JMPIjvm::jv.CIMExceptionNewISt,
                                       (jint)4, // CIM_ERR_INVALID_PARAMETER
                                       jEnv->NewStringUTF ("Invalid association class name"));

         jEnv->Throw ((jthrowable)ev);

         return 0;
      }
   }

   jEnv->ReleaseStringUTFChars (jAssocClass, str);

   str = jEnv->GetStringUTFChars (jRole, NULL);

   String role (str);

   jEnv->ReleaseStringUTFChars (jRole, str);

   try {
      checkNs (cop,jNs);

      Array<CIMObjectPath> enm = cCc->referenceNames (cop->getNameSpace (),
                                                    *cop,
                                                    assocClass,
                                                    role);

      return DEBUG_ConvertCToJava (Array<CIMObjectPath>*, jint, new Array<CIMObjectPath> (enm));
   }
   Catch (jEnv);

   return 0;
}

JNIEXPORT jint JNICALL Java_org_pegasus_jmpi_CIMClient__1references
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jNs, jint jCop,
   jstring jAssocClass, jstring jRole,
   jboolean includeQualifiers, jboolean includeClassOrigin, jobjectArray jPl)
{
   CIMClient       *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath   *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   CIMPropertyList  pl  = getList (jEnv, jPl);
   const char      *str = jEnv->GetStringUTFChars (jAssocClass, NULL);

   CIMName assocClass;

   if (  str
      && *str
      )
   {
      if (CIMName::legal (str))
      {
         assocClass = str;
      }
      else
      {
         jobject ev = jEnv->NewObject (JMPIjvm::jv.CIMExceptionClassRef,
                                       JMPIjvm::jv.CIMExceptionNewISt,
                                       (jint)4, // CIM_ERR_INVALID_PARAMETER
                                       jEnv->NewStringUTF ("Invalid association class name"));

         jEnv->Throw ((jthrowable)ev);

         return 0;
      }
   }

   jEnv->ReleaseStringUTFChars (jAssocClass, str);
   str = jEnv->GetStringUTFChars (jRole, NULL);

   String role (str);

   jEnv->ReleaseStringUTFChars (jRole, str);

   try {
      checkNs (cop,jNs);
      Array<CIMObject> enm = cCc->references (cop->getNameSpace (),
                                            *cop,
                                            assocClass,
                                            role,
                                            (Boolean)includeQualifiers,
                                            (Boolean)includeClassOrigin,
                                            pl);
      Array<CIMInstance> *enmInst = new Array<CIMInstance> ();

      for (int i = 0,m = enm.size (); i<m; i++)
      {
         enmInst->append (CIMInstance (enm[i]));
      }

      return DEBUG_ConvertCToJava (Array<CIMInstance>*, jint, enmInst);
   }
   Catch (jEnv);

   return 0;
}

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 void JNICALL Java_org_pegasus_jmpi_CIMClient__1createNameSpace
  (JNIEnv *jEnv, jobject jThs, jint jCc, jstring jNs)
{
   CIMClient  *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   const char *str = jEnv->GetStringUTFChars (jNs,NULL);
   String      ns (str);

   jEnv->ReleaseStringUTFChars (jNs,str);

   String lastNsComp;
   String nsBase;

   normalizeNs (ns,nsBase,lastNsComp);

   CIMInstance newInstance (CIMName ("__Namespace"));
   newInstance.addProperty (CIMProperty (CIMName ("name"),lastNsComp));

   try {
      cCc->createInstance (CIMNamespaceName (nsBase),newInstance);
   }
   Catch (jEnv);
}

JNIEXPORT jobject JNICALL Java_org_pegasus_jmpi_CIMClient__1enumerateNameSpaces
  (JNIEnv *jEnv, jobject jThs, jint jCc, jint jCop, jboolean deep, jobject jVec)
{
   JMPIjvm::cacheIDs (jEnv);

   CIMClient     *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   CIMObjectPath *cop = DEBUG_ConvertJavaToC (jint, CIMObjectPath*, jCop);
   String         ns  = cop->getNameSpace ().getString ();

   try {
      Array<CIMObjectPath> enm = cCc->enumerateInstanceNames(
         cop->getNameSpace (),CIMName ("__Namespace"));
      for (int i = 0, s = enm.size (); i < s; i++)
      {
         CIMObjectPath &cop = enm[i];
         const Array<CIMKeyBinding>& kb = cop.getKeyBindings ();
         const String &n = kb[0].getValue ();
         if (!deep && n.find ('/')!= PEG_NOT_FOUND)
            continue;
         String x = ns+"/"+n;
         jstring str = jEnv->NewStringUTF (x.getCString ());
         jEnv->CallVoidMethod (jVec,JMPIjvm::jv.VectorAddElement,str);
      }
   }
   Catch (jEnv);

   return jVec;
}

JNIEXPORT void JNICALL Java_org_pegasus_jmpi_CIMClient__1deleteNameSpace
  (JNIEnv *jEnv, jobject jThs, jint jCc, jstring jNs)
{
   CIMClient  *cCc = DEBUG_ConvertJavaToC (jint, CIMClient*, jCc);
   const char *str = jEnv->GetStringUTFChars (jNs,NULL);
   String      ns (str);

   jEnv->ReleaseStringUTFChars (jNs,str);

   String lastNsComp;
   String nsBase;

   normalizeNs (ns,nsBase,lastNsComp);

   CIMObjectPath cop (String::EMPTY,CIMNamespaceName (nsBase),CIMName ("__Namespace"));
   Array<CIMKeyBinding> kb;
   kb.append (CIMKeyBinding (("Name"),CIMValue (lastNsComp)));
   cop.setKeyBindings (kb);

   try {
      cCc->deleteInstance (CIMNamespaceName (nsBase),cop);
   }
   Catch (jEnv);
}

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

   delete cCc;

   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 = (jobjectArray)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 jWQLStmt)
{
   WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jint, WQLSelectStatement*, jWQLStmt);

   delete wql_stmt;

   DEBUG_ConvertCleanup (jint, jWQLStmt);
}

/*
 * 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);
   WQLSelectStatement *wql_stmt = NULL;
   String              queryLanguage (CALL_SIGN_WQL);
   String              query (pszQuery);

   wql_stmt = new WQLSelectStatement (queryLanguage, query);
   DDD (PEGASUS_STD (cout)<<"--- Java_org_pegasus_jmpi_SelectExp__1newSelectExp: wql_stmt = "<<PEGASUS_STD (hex)<< (int)wql_stmt<<PEGASUS_STD (dec)<<PEGASUS_STD (endl));

   try
   {
      WQLParser::parse (query, *wql_stmt);
   }
   catch (const Exception &e)
   {
      cerr << "Java_org_pegasus_jmpi_SelectExp__1newSelectExp: Caught: " << e.getMessage () << endl;
   }

   jEnv->ReleaseStringUTFChars (jQuery, pszQuery);

   return DEBUG_ConvertCToJava (WQLSelectStatement *, jint, wql_stmt);
}

/*
 * 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 jWQLStmt)
{
   WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jint, WQLSelectStatement*, jWQLStmt);
   String              cond;

   if (wql_stmt)
   {
      try
      {
         cond = wql_stmt->getQuery ();
      }
      catch (const Exception &e)
      {
         cerr << "Java_org_pegasus_jmpi_SelectExp__1getSelectString: Caught: " << e.getMessage () << endl;

         cond = "";
      }
   }
   else
   {
      cond = "";
   }

   return (jstring)jEnv->NewStringUTF (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 jWQLStmt, jint jciInstance)
{
   WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jint, WQLSelectStatement*, jWQLStmt);
   CIMInstance        *ci       = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciInstance);
   CIMInstance        *ciRet    = 0;

   if (  !wql_stmt
      || !ci
      )
   {
      return 0;
   }

   ciRet = new CIMInstance (ci->clone ());

   if (ciRet)
   {
      try
      {
         wql_stmt->applyProjection (*ciRet, false);
      }
      catch (const Exception &e)
      {
         cerr << "Java_org_pegasus_jmpi_JMPISelectList__1applyInstance: Caught: " << e.getMessage () << endl;

         return 0;
      }
   }

   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 jWQLStmt, jint jciClass)
{
   WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jint, WQLSelectStatement*, jWQLStmt);
   CIMClass           *cc       = DEBUG_ConvertJavaToC (jint, CIMClass*, jciClass);
   CIMClass           *ccRet    = NULL;

   if (!wql_stmt)
   {
      return 0;
   }

   if (cc)
   {
      CIMObject co (cc->clone ());

      try
      {
         wql_stmt->applyProjection (co, false);
      }
      catch (const Exception &e)
      {
         cerr << "Java_org_pegasus_jmpi_JMPISelectList__1applyClass: Caught: " << e.getMessage () << endl;

         return 0;
      }

      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 jWQLStmt, jint jciInstance)
{
   WQLSelectStatement *wql_stmt = DEBUG_ConvertJavaToC (jint, WQLSelectStatement*, jWQLStmt);
   CIMInstance        *ci       = DEBUG_ConvertJavaToC (jint, CIMInstance*, jciInstance);

   if (  !wql_stmt
      || !ci
      )
   {
      return 0;
   }

   try
   {
      return wql_stmt->evaluate (*ci);
   }
   catch (const Exception &e)
   {
      cerr << "Java_org_pegasus_jmpi_JMPIQueryExp__1applyInstance: Caught: " << e.getMessage () << endl;

      return false;
   }
}

} // extern "C"

PEGASUS_NAMESPACE_END