CmpiImpl.cpp

Go to the documentation of this file.

/*
 *
 * CmpiImpl.cpp
 *
 * (C) Copyright IBM Corp. 2003
 *
 * THIS FILE IS PROVIDED UNDER THE TERMS OF THE COMMON PUBLIC LICENSE
 * ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
 * CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
 *
 * You can obtain a current copy of the Common Public License from
 * http://oss.software.ibm.com/developerworks/opensource/license-cpl.html
 *
 * Author:        Adrian Schuur <schuur@de.ibm.com>
 * Contributors:
 *
 * Description: CMPI C++ implemenation support
 *
 */


#include "CmpiInstance.h"
#include "CmpiObjectPath.h"
#include "CmpiResult.h"
#include "CmpiDateTime.h"

#include "CmpiBaseMI.h"
#include "CmpiInstanceMI.h"
#include "CmpiAssociationMI.h"
#include "CmpiMethodMI.h"
#include "CmpiPropertyMI.h"
#include "CmpiIndicationMI.h"
#include "CmpiArray.h"
#include "CmpiBroker.h"
#include "cmpisrv.h"

//CMPIBroker *CmpiBaseMI::broker=NULL;
//int CmpiBaseMI::oneTime=0;

CmpiProviderBase* CmpiProviderBase::base = NULL;

//---------------------------------------------------
//--
// C to C++ base provider function drivers
//--
//---------------------------------------------------


CMPIStatus CmpiBaseMI::doDriveBaseCleanup
      (void* vi, CMPIContext* eCtx) {
   CMPIInstanceMI *mi=( CMPIInstanceMI*)vi;
   CmpiContext ctx(eCtx);
   CmpiStatus rc(CMPI_RC_OK);
   rc=((CmpiInstanceMI*)mi->hdl)->cleanup(ctx);
   delete (CmpiBaseMI*)mi->hdl;
   return rc.status();
}
CmpiStatus CmpiBaseMI::initialize(const CmpiContext& ctx) {
   return CmpiStatus(CMPI_RC_OK);
}

CmpiStatus CmpiBaseMI::cleanup(CmpiContext& ctx) {
   return CmpiStatus(CMPI_RC_OK);
}

//---------------------------------------------------
//--
// C to C++ instance provider function drivers
//--
//---------------------------------------------------

CMPIStatus CmpiInstanceMI::driveEnumInstanceNames
   (CMPIInstanceMI* mi,CMPIContext* eCtx, CMPIResult* eRslt,
    CMPIObjectPath* eCop)
{
   CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   CmpiObjectPath cop(eCop);
   return ((CmpiInstanceMI*)mi->hdl)->enumInstanceNames
      (ctx,rslt,cop).status();
}

CMPIStatus CmpiInstanceMI::driveEnumInstances
   (CMPIInstanceMI* mi, CMPIContext* eCtx, CMPIResult* eRslt,
    CMPIObjectPath* eCop, char* *properties)
{
   CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   CmpiObjectPath cop(eCop);
   return ((CmpiInstanceMI*)mi->hdl)->enumInstances
      (ctx,rslt,cop,(const char**)properties).status();
}

CMPIStatus CmpiInstanceMI::driveGetInstance
   (CMPIInstanceMI* mi, CMPIContext* eCtx, CMPIResult* eRslt,
    CMPIObjectPath* eCop, char* *properties)
{
   CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   CmpiObjectPath cop(eCop);
   return ((CmpiInstanceMI*)mi->hdl)->getInstance
      (ctx,rslt,cop,(const char**)properties).status();
}

CMPIStatus CmpiInstanceMI::driveCreateInstance
   (CMPIInstanceMI* mi, CMPIContext* eCtx, CMPIResult* eRslt,
    CMPIObjectPath* eCop, CMPIInstance* eInst)
{
   CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   CmpiObjectPath cop(eCop);
   CmpiInstance inst(eInst);
   return ((CmpiInstanceMI*)mi->hdl)->createInstance
      (ctx,rslt,cop,inst).status();
}

CMPIStatus CmpiInstanceMI::driveSetInstance
   (CMPIInstanceMI* mi, CMPIContext* eCtx, CMPIResult* eRslt,
    CMPIObjectPath* eCop, CMPIInstance* eInst, char* *properties)
{
   CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   CmpiObjectPath cop(eCop);
   CmpiInstance inst(eInst);
   return ((CmpiInstanceMI*)mi->hdl)->setInstance
      (ctx,rslt,cop,inst,(const char**)properties).status();
}

CMPIStatus CmpiInstanceMI::driveDeleteInstance
   (CMPIInstanceMI* mi, CMPIContext* eCtx, CMPIResult* eRslt,
    CMPIObjectPath* eCop)
{
   CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   CmpiObjectPath cop(eCop);
   return ((CmpiInstanceMI*)mi->hdl)->deleteInstance
      (ctx,rslt,cop).status();
}

CMPIStatus CmpiInstanceMI::driveExecQuery
   (CMPIInstanceMI* mi, CMPIContext* eCtx, CMPIResult* eRslt,
    CMPIObjectPath* eCop, char* language ,char* query)
{
   CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   CmpiObjectPath cop(eCop);
   return ((CmpiInstanceMI*)mi->hdl)->execQuery
    (ctx,rslt,cop,language,query).status();
}


//---------------------------------------------------
//--
// Default Instance provider functions
//--
//---------------------------------------------------

CmpiStatus CmpiInstanceMI::enumInstanceNames
              (const CmpiContext& ctx, CmpiResult& rslt, const CmpiObjectPath& cop) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiInstanceMI::enumInstances
              (const CmpiContext& ctx, CmpiResult& rslt, const CmpiObjectPath& cop,
          const char* *properties){
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiInstanceMI::getInstance
              (const CmpiContext& ctx, CmpiResult& rslt, const CmpiObjectPath& cop,
          const char* *properties) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiInstanceMI::createInstance
              (const CmpiContext& ctx, CmpiResult& rslt, const CmpiObjectPath& cop,
               const CmpiInstance& inst) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiInstanceMI::setInstance
              (const CmpiContext& ctx, CmpiResult& rslt, const CmpiObjectPath& cop,
              const  CmpiInstance& inst, const char* *properties) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiInstanceMI::deleteInstance
              (const CmpiContext& ctx, CmpiResult& rslt, const CmpiObjectPath& cop) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiInstanceMI::execQuery
              (const CmpiContext& ctx, CmpiResult& rslt, const CmpiObjectPath& cop,
               const char* language, const char* query) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}


//---------------------------------------------------
//--
// C to C++ association provider function drivers
//--
//---------------------------------------------------

CMPIStatus CmpiAssociationMI::driveAssociators
      (CMPIAssociationMI* mi, CMPIContext* eCtx, CMPIResult* eRslt,
       CMPIObjectPath* eOp, char* assocClass, char* resultClass,
       char* role, char* resultRole, char** properties) {
   CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   CmpiObjectPath cop(eOp);
   return ((CmpiAssociationMI*)mi->hdl)->associators
      (ctx,rslt,cop,
       (const char*)assocClass,(const char*)resultClass,
       (const char*)role,(const char*)resultRole,(const char**)properties).status();
}

CMPIStatus CmpiAssociationMI::driveAssociatorNames
      (CMPIAssociationMI* mi, CMPIContext* eCtx, CMPIResult* eRslt,
       CMPIObjectPath* eOp, char* assocClass, char* resultClass,
       char* role, char* resultRole) {
   CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   CmpiObjectPath cop(eOp);
   return ((CmpiAssociationMI*)mi->hdl)->associatorNames
      (ctx,rslt,cop,
       (const char*)assocClass,(const char*)resultClass,
       (const char*)role,(const char*)resultRole).status();
}

CMPIStatus CmpiAssociationMI::driveReferences
      (CMPIAssociationMI* mi, CMPIContext* eCtx, CMPIResult* eRslt,
       CMPIObjectPath* eOp, char* resultClass, char* role ,
       char** properties) {
   CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   CmpiObjectPath cop(eOp);
   return ((CmpiAssociationMI*)mi->hdl)->references
      (ctx,rslt,cop,
       (const char*)resultClass,(const char*)role,(const char**)properties).status();
}

CMPIStatus CmpiAssociationMI::driveReferenceNames
      (CMPIAssociationMI* mi, CMPIContext* eCtx, CMPIResult* eRslt,
       CMPIObjectPath* eOp, char* resultClass, char* role) {
   CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   CmpiObjectPath cop(eOp);
   return ((CmpiAssociationMI*)mi->hdl)->referenceNames
      (ctx,rslt,cop,
       (const char*)resultClass,(const char*)role).status();
}


//---------------------------------------------------
//--
// Default Association provider functions
//--
//---------------------------------------------------

CmpiStatus CmpiAssociationMI::associators
      (const CmpiContext& ctx, CmpiResult& rslt,
       const CmpiObjectPath& op, const char* assocClass, const char* resultClass,
       const char* role, const char* resultRole, const char** properties) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiAssociationMI::associatorNames
      (const CmpiContext& ctx, CmpiResult& rslt,
       const CmpiObjectPath& op, const char* assocClass, const char* resultClass,
       const char* role, const char* resultRole) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiAssociationMI::references
      (const CmpiContext& ctx, CmpiResult& rslt,
       const CmpiObjectPath& op, const char* resultClass, const char* role ,
       const char** properties) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiAssociationMI::referenceNames
      (const CmpiContext& ctx, CmpiResult& rslt,
       const CmpiObjectPath& op, const char* resultClass, const char* role) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}


//---------------------------------------------------
//--
// C to C++ method provider function drivers
//--
//---------------------------------------------------

CMPIStatus CmpiMethodMI::driveInvokeMethod
   (CMPIMethodMI* mi, CMPIContext* eCtx, CMPIResult* eRslt,
    CMPIObjectPath* eCop, char* methodName,
    CMPIArgs* eIn, CMPIArgs* eOut)
{
   const CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   const CmpiObjectPath cop(eCop);
   const CmpiArgs in(eIn);
   CmpiArgs out(eOut);
   return ((CmpiMethodMI*)mi->hdl)->invokeMethod
      (ctx,rslt,cop,(const char*)methodName,in,out).status();
}


//---------------------------------------------------
//--
// Default Method provider functions
//--
//---------------------------------------------------

CmpiStatus CmpiMethodMI::invokeMethod
              (const CmpiContext& ctx, CmpiResult& rslt,
          const CmpiObjectPath& ref, const char* methodName,
          const CmpiArgs& in, CmpiArgs& out) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}


//---------------------------------------------------
//--
// C to C++ property provider function drivers
//--
//---------------------------------------------------

CMPIStatus CmpiPropertyMI::driveSetProperty
      (CMPIPropertyMI* mi, CMPIContext* eCtx, CMPIResult* eRslt,
       CMPIObjectPath* eCop, char* name, CMPIData eData) {
   const CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   const CmpiObjectPath cop(eCop);
   const CmpiData data(eData);
   return ((CmpiPropertyMI*)mi->hdl)->setProperty
      (ctx,rslt,cop,(const char*)name,data).status();
}

CMPIStatus CmpiPropertyMI::driveGetProperty
      (CMPIPropertyMI* mi, CMPIContext* eCtx, CMPIResult* eRslt,
       CMPIObjectPath* eCop, char* name) {
   const CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   const CmpiObjectPath cop(eCop);
   return ((CmpiPropertyMI*)mi->hdl)->getProperty
      (ctx,rslt,cop,(const char*)name).status();
}


//---------------------------------------------------
//--
// Default property provider functions
//--
//---------------------------------------------------

CmpiStatus CmpiPropertyMI::setProperty
      (const CmpiContext& ctx, CmpiResult& rslt,
       const CmpiObjectPath& op, const char* name, const CmpiData& data) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiPropertyMI::getProperty
      (const CmpiContext& ctx, CmpiResult& rslt,
       const CmpiObjectPath& op, const char* name) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}


//---------------------------------------------------
//--
// C to C++ indication provider function drivers
//--
//---------------------------------------------------

CMPIStatus CmpiIndicationMI::driveAuthorizeFilter
      (CMPIIndicationMI* mi, CMPIContext* eCtx, CMPIResult* eRslt,
       CMPISelectExp* eSe, char* ns, CMPIObjectPath* eCop, char* user){
   const CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   const CmpiObjectPath cop(eCop);
   const CmpiSelectExp se(eSe);
   return ((CmpiIndicationMI*)mi->hdl)->authorizeFilter
      (ctx,rslt,se,(const char*)ns,cop,(const char*)user).status();
}

CMPIStatus CmpiIndicationMI::driveMustPoll
      (CMPIIndicationMI* mi, CMPIContext* eCtx, CMPIResult* eRslt,
       CMPISelectExp* eSe, char* ns, CMPIObjectPath* eCop){
   const CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   const CmpiObjectPath cop(eCop);
   const CmpiSelectExp se(eSe);
   return ((CmpiIndicationMI*)mi->hdl)->mustPoll
      (ctx,rslt,se,(const char*)ns,cop).status();
}

CMPIStatus CmpiIndicationMI::driveActivateFilter
      (CMPIIndicationMI* mi, CMPIContext* eCtx, CMPIResult* eRslt,
       CMPISelectExp* eSe, char* ns, CMPIObjectPath* eCop, CMPIBoolean first){
   const CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   const CmpiObjectPath cop(eCop);
   const CmpiSelectExp se(eSe);
   return ((CmpiIndicationMI*)mi->hdl)->activateFilter
      (ctx,rslt,se,(const char*)ns,cop,first).status();
}

CMPIStatus CmpiIndicationMI::driveDeActivateFilter
      (CMPIIndicationMI* mi, CMPIContext* eCtx, CMPIResult* eRslt,
       CMPISelectExp* eSe, char* ns, CMPIObjectPath* eCop, CMPIBoolean last){
   const CmpiContext ctx(eCtx);
   CmpiResult rslt(eRslt);
   const CmpiObjectPath cop(eCop);
   const CmpiSelectExp se(eSe);
   return ((CmpiIndicationMI*)mi->hdl)->deActivateFilter
      (ctx,rslt,se,(const char*)ns,cop,last).status();
}


//---------------------------------------------------
//--
// Default indication provider functions
//--
//---------------------------------------------------

CmpiStatus CmpiIndicationMI::authorizeFilter
      (const CmpiContext& ctx, CmpiResult& rslt,
       const CmpiSelectExp& se, const char* ns, const CmpiObjectPath& op, const char* user) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiIndicationMI::mustPoll
      (const CmpiContext& ctx, CmpiResult& rslt,
       const CmpiSelectExp& se, const char* ns, const CmpiObjectPath& op) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiIndicationMI::activateFilter
      (const CmpiContext& ctx, CmpiResult& rslt,
       const CmpiSelectExp& se, const char* ns, const CmpiObjectPath& op,
       CMPIBoolean first) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiStatus CmpiIndicationMI::deActivateFilter
      (const CmpiContext& ctx, CmpiResult& rslt,
       const CmpiSelectExp& se, const char* ns, const CmpiObjectPath& op,
       CMPIBoolean last) {
   return CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}






//---------------------------------------------------
//--
// CmpiArray member functions
//--
//---------------------------------------------------

void *CmpiArray::makeArray(CMPIBroker *mb, CMPICount max, CMPIType type) {
   CMPIStatus rc;
   void *array=mb->eft->newArray(mb,max,type,&rc);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
   return array;
}

CMPICount CmpiArray::size() {
   CMPIStatus rc;
   CMPICount c=getEnc()->ft->getSize(getEnc(),&rc);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
   return c;
}

//---------------------------------------------------
//--
// CmpiArrayIdx member functions
//--
//---------------------------------------------------


void CmpiArrayIdx::operator=(const CmpiString v) {
   CMPIStatus rc;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_string)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   rc=ar.getEnc()->ft->setElementAt(ar.getEnc(),idx,(CMPIValue*)&v,CMPI_string);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
}

void CmpiArrayIdx::operator=(const char* v) {
   CMPIStatus rc;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_chars)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   rc=ar.getEnc()->ft->setElementAt(ar.getEnc(),idx,(CMPIValue*)&v,CMPI_chars);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
}

void CmpiArrayIdx::operator=(const CMPISint8 v) {
   CMPIStatus rc;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_sint8)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   rc=ar.getEnc()->ft->setElementAt(ar.getEnc(),idx,(CMPIValue*)&v,CMPI_sint8);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
}

void CmpiArrayIdx::operator=(const CMPISint16 v) {
   CMPIStatus rc;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_sint16)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   rc=ar.getEnc()->ft->setElementAt(ar.getEnc(),idx,(CMPIValue*)&v,CMPI_sint16);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
}

void CmpiArrayIdx::operator=(const CMPISint32 v) {
   CMPIStatus rc;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_sint32)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   rc=ar.getEnc()->ft->setElementAt(ar.getEnc(),idx,(CMPIValue*)&v,CMPI_sint32);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
}

void CmpiArrayIdx::operator=(const int v) {
   CMPIStatus rc;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_sint32)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   rc=ar.getEnc()->ft->setElementAt(ar.getEnc(),idx,(CMPIValue*)&v,CMPI_sint32);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
}


void CmpiArrayIdx::operator=(const CMPISint64 v) {
   CMPIStatus rc;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_sint64)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   rc=ar.getEnc()->ft->setElementAt(ar.getEnc(),idx,(CMPIValue*)&v,CMPI_sint64);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
}

void CmpiArrayIdx::operator=(const CMPIUint8 v) {
   CMPIStatus rc;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_uint8)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   rc=ar.getEnc()->ft->setElementAt(ar.getEnc(),idx,(CMPIValue*)&v,CMPI_uint8);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
}

void CmpiArrayIdx::operator=(const CMPIUint16 v) {
   CMPIStatus rc;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_uint16)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   rc=ar.getEnc()->ft->setElementAt(ar.getEnc(),idx,(CMPIValue*)&v,CMPI_uint16);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
}

void CmpiArrayIdx::operator=(const CMPIUint32 v) {
   CMPIStatus rc;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_uint32)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   rc=ar.getEnc()->ft->setElementAt(ar.getEnc(),idx,(CMPIValue*)&v,CMPI_uint32);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
}

void CmpiArrayIdx::operator=(const unsigned int v) {
   CMPIStatus rc;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_uint32)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   rc=ar.getEnc()->ft->setElementAt(ar.getEnc(),idx,(CMPIValue*)&v,CMPI_uint32);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
}

void CmpiArrayIdx::operator=(const CMPIUint64 v) {
   CMPIStatus rc;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_uint64)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   rc=ar.getEnc()->ft->setElementAt(ar.getEnc(),idx,(CMPIValue*)&v,CMPI_uint64);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
}


void CmpiArrayIdx::operator>>(CmpiString& v) {
   CMPIStatus rc;
   CMPIData d;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_string)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   d=ar.getEnc()->ft->getElementAt(ar.getEnc(),idx,&rc);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
   v=CmpiString(d.value.string);
}

void CmpiArrayIdx::operator>>(CMPISint8& v) {
   CMPIStatus rc;
   CMPIData d;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_sint8)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   d=ar.getEnc()->ft->getElementAt(ar.getEnc(),idx,&rc);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
   v=d.value.sint8;
}

void CmpiArrayIdx::operator>>(CMPISint16& v) {
   CMPIStatus rc;
   CMPIData d;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_sint16)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   d=ar.getEnc()->ft->getElementAt(ar.getEnc(),idx,&rc);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
   v=d.value.sint16;
}

void CmpiArrayIdx::operator>>(CMPISint32& v) {
   CMPIStatus rc;
   CMPIData d;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_sint32)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   d=ar.getEnc()->ft->getElementAt(ar.getEnc(),idx,&rc);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
   v=d.value.sint32;
}

void CmpiArrayIdx::operator>>(int& v) {
   CMPIStatus rc;
   CMPIData d;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_sint32)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   d=ar.getEnc()->ft->getElementAt(ar.getEnc(),idx,&rc);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
   v=(int)d.value.sint32;
}

void CmpiArrayIdx::operator>>(CMPISint64& v) {
   CMPIStatus rc;
   CMPIData d;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_sint64)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   d=ar.getEnc()->ft->getElementAt(ar.getEnc(),idx,&rc);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
   v=(int)d.value.sint64;
}

void CmpiArrayIdx::operator>>(CMPIUint8& v) {
   CMPIStatus rc;
   CMPIData d;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_uint8)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   d=ar.getEnc()->ft->getElementAt(ar.getEnc(),idx,&rc);
   if (rc.rc!=CMPI_RC_OK) throw rc.rc;
   v=d.value.uint8;
}

void CmpiArrayIdx::operator>>(CMPIUint16& v) {
   CMPIStatus rc;
   CMPIData d;
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=CMPI_uint16)
      throw CMPI_RC_ERR_TYPE_MISMATCH;
   d=ar.getEnc()->ft->getElementAt(ar.getEnc(),idx,&rc);
   if (rc.rc!=