cmpiimpl.cpp

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

   CmpiMethodMI* mmi = dynamic_cast<CmpiMethodMI*>(cmi);
   return mmi->invokeMethod
      (ctx,rslt,cop,methodName,in,out).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.status();
  }
}


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

CmpiMethodMI::CmpiMethodMI(const CmpiBroker &mbp, const CmpiContext& ctx)
   : CmpiBaseMI (mbp,ctx) {
}

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

CmpiPropertyMI::CmpiPropertyMI(const CmpiBroker &mbp, const CmpiContext& ctx)
   : CmpiBaseMI (mbp,ctx) {
}

CMPIStatus CmpiPropertyMI::driveSetProperty
      (CMPIPropertyMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
       const CMPIObjectPath* eCop, const char* name, CMPIData eData) {
  try {
   const CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   const CmpiObjectPath cop((CMPIObjectPath*)eCop);
   const CmpiData data(eData);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiPropertyMI* pmi = dynamic_cast<CmpiPropertyMI*>(cmi);
   return pmi->setProperty
      (ctx,rslt,cop,name,data).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.status();
  }
}

CMPIStatus CmpiPropertyMI::driveGetProperty
      (CMPIPropertyMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
       const CMPIObjectPath* eCop, const char* name) {
  try {
   const CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   const CmpiObjectPath cop((CMPIObjectPath*)eCop);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiPropertyMI* pmi = dynamic_cast<CmpiPropertyMI*>(cmi);
   return pmi->getProperty
      (ctx,rslt,cop,name).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.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
//--
//---------------------------------------------------

CmpiIndicationMI::CmpiIndicationMI(const CmpiBroker &mbp, const CmpiContext& ctx)
   : CmpiBaseMI (mbp,ctx) {
}

CMPIStatus CmpiIndicationMI::driveAuthorizeFilter
      (CMPIIndicationMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
       const CMPISelectExp* eSe, const char* ns, const CMPIObjectPath* eCop, 
       const char* user){
  try {
   const CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   const CmpiObjectPath cop((CMPIObjectPath*)eCop);
   const CmpiSelectExp se(eSe);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiIndicationMI* nmi = dynamic_cast<CmpiIndicationMI*>(cmi);
   return nmi->authorizeFilter
      (ctx,rslt,se,ns,cop,user).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.status();
  }
}

CMPIStatus CmpiIndicationMI::driveMustPoll
      (CMPIIndicationMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
       const CMPISelectExp* eSe, const char* ns, const CMPIObjectPath* eCop){
  try {
   const CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   const CmpiObjectPath cop((CMPIObjectPath*)eCop);
   const CmpiSelectExp se(eSe);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiIndicationMI* nmi = dynamic_cast<CmpiIndicationMI*>(cmi);
   return nmi->mustPoll
      (ctx,rslt,se,ns,cop).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.status();
  }
}

CMPIStatus CmpiIndicationMI::driveActivateFilter
      (CMPIIndicationMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
       const CMPISelectExp* eSe, const char* ns, const CMPIObjectPath* eCop, 
       CMPIBoolean first){
  try {
   const CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   const CmpiObjectPath cop((CMPIObjectPath*)eCop);
   const CmpiSelectExp se(eSe);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiIndicationMI* nmi = dynamic_cast<CmpiIndicationMI*>(cmi);
   return nmi->activateFilter
      (ctx,rslt,se,ns,cop,first).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.status();
  }
}

CMPIStatus CmpiIndicationMI::driveDeActivateFilter
      (CMPIIndicationMI* mi, const CMPIContext* eCtx, const CMPIResult* eRslt,
       const CMPISelectExp* eSe, const char* ns, const CMPIObjectPath* eCop, 
       CMPIBoolean last){
  try {
   const CmpiContext ctx((CMPIContext*)eCtx);
   CmpiResult rslt((CMPIResult*)eRslt);
   const CmpiObjectPath cop((CMPIObjectPath*)eCop);
   const CmpiSelectExp se(eSe);
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiIndicationMI* nmi = dynamic_cast<CmpiIndicationMI*>(cmi);
   return nmi->deActivateFilter
      (ctx,rslt,se,ns,cop,last).status();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
    return stat.status();
  }
}

void CmpiIndicationMI::driveEnableIndications
      (CMPIIndicationMI* mi)
{
  try {
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiIndicationMI* nmi = dynamic_cast<CmpiIndicationMI*>(cmi);
   nmi->enableIndications
     ();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
  }
}

void CmpiIndicationMI::driveDisableIndications
      (CMPIIndicationMI* mi)
{
  try {
   CmpiBaseMI* cmi = reinterpret_cast<CmpiBaseMI*> (mi->hdl);
   CmpiIndicationMI* nmi = dynamic_cast<CmpiIndicationMI*>(cmi);
   nmi->disableIndications
     ();
  } catch (const CmpiStatus& stat) {
#ifdef PEGASUS_DEBUG
    cerr << "caught status :" << stat.rc() << " "  << stat.msg() << endl;
#endif
  }
}


//---------------------------------------------------
//--
//	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);
}

void CmpiIndicationMI::enableIndications()
{
}

void CmpiIndicationMI::disableIndications()
{
}



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

CMPIArray *CmpiArray::getEnc() const {
   return (CMPIArray*)enc;
}

CmpiArray::CmpiArray(CMPIArray *arr) {
   enc=arr;
}

CmpiArray::CmpiArray(CMPICount max, CMPIType type) {
   enc=makeArray(CmpiProviderBase::getBroker(),max,type);
}

CmpiArray::CmpiArray() {
}

CmpiArrayIdx CmpiArray::operator[](int idx) const {
   return CmpiArrayIdx(*this,idx);
}

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

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

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


CmpiArrayIdx::CmpiArrayIdx(const CmpiArray &a, CMPICount i)
         : ar(a), idx(i)
{
}

#ifdef PEGASUS_CMPI_DATA_NEED_IMPLICIT_CONVERTERS

CmpiArrayIdx& CmpiArrayIdx::operator=(const CmpiData& v) {
   CMPIStatus rc={CMPI_RC_OK,NULL};
   if (ar.getEnc()->ft->getSimpleType(ar.getEnc(),&rc)!=v._data.type)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   rc=ar.getEnc()->ft->setElementAt(ar.getEnc(),idx,(CMPIValue*)&v._data.value,
				    v._data.type);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return *this;
}

#endif

CmpiData CmpiArrayIdx::getData() const{
   CMPIStatus rc={CMPI_RC_OK,NULL};
   CMPIData d;
   d=ar.getEnc()->ft->getElementAt(ar.getEnc(),idx,&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return CmpiData (d);
}

#ifdef PEGASUS_CMPI_DATA_NEED_IMPLICIT_CONVERTERS

CmpiArrayIdx::operator CmpiString() const{
   return getData().getString();
}

CmpiArrayIdx::operator const char* () const{
   return getData().getCString();
}

CmpiArrayIdx::operator CmpiDateTime() const{
   return getData().getDateTime();
}

CmpiArrayIdx::operator CmpiObjectPath() const{
   return getData().getObjectPath();
}

CmpiArrayIdx::operator CmpiInstance() const{
   return getData().getInstance();
}

CmpiArrayIdx::operator CMPIUint8() const{
   return getData().getUint8();
}

CmpiArrayIdx::operator CMPIUint16() const{
   return getData().getUint16();
}

CmpiArrayIdx::operator CMPIUint32() const{
   return getData().getUint32();
}

CmpiArrayIdx::operator CMPIUint64() const{
   return getData().getUint64();
}

CmpiArrayIdx::operator CMPISint8() const{
   return getData().getSint8();
}

CmpiArrayIdx::operator CMPISint16() const{
   return getData().getSint16();
}

CmpiArrayIdx::operator CMPISint32() const{
   return getData().getSint32();
}

CmpiArrayIdx::operator CMPISint64() const{
   return getData().getSint64();
}

CmpiArrayIdx::operator CMPIReal32() const{
   return getData().getReal32();
}

CmpiArrayIdx::operator CMPIReal64() const{
   return getData().getReal64();
}

#endif /* PEGASUS_CMPI_DATA_NEED_IMPLICIT_CONVERTERS */

CMPIBoolean CmpiArrayIdx::getBoolean() const
{
    return getData().getBoolean();
}

CMPIUint8 CmpiArrayIdx::getUint8() const
{
    return getData().getUint8();
}

CMPISint8 CmpiArrayIdx::getSint8() const
{
    return getData().getSint8();
}

CMPIUint16 CmpiArrayIdx::getUint16() const
{
    return getData().getUint16();
}

CMPISint16 CmpiArrayIdx::getSint16() const
{
    return getData().getSint16();
}

CMPIUint32 CmpiArrayIdx::getUint32() const
{
    return getData().getUint32();
}

CMPISint32 CmpiArrayIdx::getSint32() const
{
    return getData().getSint32();
}

CMPIUint64 CmpiArrayIdx::getUint64() const
{
    return getData().getUint64();
}

CMPISint64 CmpiArrayIdx::getSint64() const
{
    return getData().getSint64();
}

CMPIReal32 CmpiArrayIdx::getReal32() const
{
    return getData().getReal32();
}

CMPIReal64 CmpiArrayIdx::getReal64() const
{
    return getData().getReal64();
}

CMPIChar16 CmpiArrayIdx::getChar16() const
{
    return getData().getChar16();
}

CmpiString CmpiArrayIdx::getString() const
{
    return getData().getString();
}

CmpiDateTime CmpiArrayIdx::getDateTime() const
{
    return getData().getDateTime();
}

//---------------------------------------------------
//--
//	CmpiData member functions