cmpiimpl.cpp

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

   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
}

void CmpiBroker::deleteInstance(const CmpiContext& ctx, const CmpiObjectPath& cop)
{
   CMPIStatus rc=getEnc()->bft->deleteInstance
     (getEnc(),ctx.getEnc(),cop.getEnc());
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
}

CmpiEnumeration CmpiBroker::execQuery(const CmpiContext& ctx,
                          const  CmpiObjectPath& cop,
                          const char* query, const char* language)
{
   throw CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
   return NULL;
}


CmpiEnumeration CmpiBroker::enumInstances(const CmpiContext& ctx,
                              const CmpiObjectPath& cop,
                              const char** properties)
{
   CMPIStatus rc={CMPI_RC_OK,NULL};
   CMPIEnumeration* en=getEnc()->bft->enumInstances
      (getEnc(),ctx.getEnc(),cop.getEnc(),properties,&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return CmpiEnumeration(en);
}

CmpiEnumeration CmpiBroker::associators(const CmpiContext& ctx,
                            const CmpiObjectPath& cop,
                            const char* assocClass, const char* resultClass,
		            const char* role, const char* resultRole,
			    const char** properties)
{
   throw CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
   return NULL;
}

CmpiEnumeration CmpiBroker::associatorNames(const CmpiContext& ctx,
                                const CmpiObjectPath& cop,
                                const char* assocClass, const char* resultClass,
		                const char* role, const char* resultRole)
{
   throw CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
   return NULL;
}

CmpiEnumeration CmpiBroker::references(const CmpiContext& ctx,
                           const CmpiObjectPath& cop,
                           const char* resultClass, const char* role,
			   const char** properties)
{
   throw CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
   return NULL;
}

CmpiEnumeration CmpiBroker::referenceNames(const CmpiContext& ctx,
                               const CmpiObjectPath& cop,
                               const char* resultClass, const char* role)
{
   throw CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
   return NULL;
}

CmpiData CmpiBroker::invokeMethod(const CmpiContext& ctx, const CmpiObjectPath& cop,
                 const char* methName, const CmpiArgs& in, CmpiArgs& out)
{
   throw CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
   return CmpiData();
}

void CmpiBroker::setProperty(const CmpiContext& ctx, const CmpiObjectPath& cop,
                 const char* name, const CmpiData& data)
{
   throw CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
}

CmpiData CmpiBroker::getProperty(const CmpiContext& ctx, const CmpiObjectPath& cop,
                  const char* name)
{
   throw CmpiStatus(CMPI_RC_ERR_NOT_SUPPORTED);
   return CmpiData();
}




//---------------------------------------------------
//--
//	CmpiString member functions
//--
//---------------------------------------------------




CmpiString::CmpiString(const CmpiString& s) {
  enc=CMNewString(CmpiProviderBase::getBroker(),(char*)s.charPtr(),NULL);
}

CmpiString::CmpiString(CMPIString* c) {
   enc=c;
}

CMPIString *CmpiString::getEnc() const {
   return (CMPIString*)enc;
}

CmpiString::CmpiString() {
   enc=NULL;
}
const char* CmpiString::charPtr() const {
   if (getEnc())
      return (const char*)getEnc()->hdl;
   else
      return NULL;
}

CmpiBoolean CmpiString::equals(const char *str) const {
   return (strcmp(charPtr(),str)==0);
}

CmpiBoolean CmpiString::equals(const CmpiString& str) const {
   return (strcmp(charPtr(),str.charPtr())==0);
}

CmpiBoolean CmpiString::equalsIgnoreCase(const char *str) const {
   return (strcasecmp(charPtr(),str)==0);
}

CmpiBoolean CmpiString::equalsIgnoreCase(const CmpiString& str) const {
   return (strcasecmp(charPtr(),str.charPtr())==0);
}


//---------------------------------------------------
//--
//	CmpiArgs member functions
//--
//---------------------------------------------------


CmpiArgs::CmpiArgs(CMPIArgs* newEnc) {
   this->enc=newEnc;
}

CmpiArgs::CmpiArgs() {
   this->enc=makeArgs(CmpiProviderBase::getBroker());
}

CMPIArgs *CmpiArgs::getEnc() const {
   return (CMPIArgs*)enc;
}

void *CmpiArgs::makeArgs(CMPIBroker *mb) {
   CMPIStatus rc={CMPI_RC_OK,NULL};
   void *args=mb->eft->newArgs(mb,&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return args;
}

void CmpiArgs::setArg(const char* name, const CmpiData& data) {
   CMPIStatus rc=getEnc()->ft->addArg(getEnc(),name,
         data._data.type!=CMPI_chars ? (CMPIValue*)&data._data.value
	                            : (CMPIValue*)data._data.value.chars,
         data._data.type);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
}

CmpiData CmpiArgs::getArg(const int pos, CmpiString *name) const {
   CmpiData d;
   CMPIStatus rc={CMPI_RC_OK,NULL};
   CMPIString *s;
   d._data=getEnc()->ft->getArgAt(getEnc(),(int)pos,&s,&rc);
   if (rc.rc!=CMPI_RC_OK && rc.rc!=CMPI_RC_ERR_NOT_FOUND) {
     if (rc.msg)
       throw CmpiStatus(rc);
     else
       throw CmpiStatus(rc.rc,name->charPtr());
   }
   if (name) *name=CmpiString(s);
   return CmpiData (d);
}

CmpiData CmpiArgs::getArg(const char* name) const {
   CmpiData d;
   CMPIStatus rc={CMPI_RC_OK,NULL};
   d._data=getEnc()->ft->getArg(getEnc(),name,&rc);
   if (rc.rc!=CMPI_RC_OK && rc.rc!=CMPI_RC_ERR_NOT_FOUND) {
     if (rc.msg)
       throw CmpiStatus(rc);
     else
       throw CmpiStatus(rc.rc,name);
   }
   return CmpiData (d);
}

unsigned int CmpiArgs::getArgCount() const {
   CMPIStatus rc={CMPI_RC_OK,NULL};
   unsigned int c=getEnc()->ft->getArgCount(getEnc(),&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return c;
}



//---------------------------------------------------
//--
//	CmpiObject member functions
//--
//---------------------------------------------------


CmpiObject::CmpiObject()
   : enc(0) {
 }

CmpiObject::CmpiObject(const void* newEnc) {
   this->enc=(void*)newEnc;
}

CmpiBoolean CmpiObject::isNull() const {
   return (this->enc==NULL);
}

CmpiString CmpiObject::toString() {
   return doToString(CmpiProviderBase::getBroker());
}

CmpiBoolean CmpiObject::isA(const char *typeName) const  {
   return doIsA(CmpiProviderBase::getBroker(),typeName);
}

CmpiString CmpiObject::doToString(CMPIBroker *mb) {
   CMPIStatus rc={CMPI_RC_OK,NULL};
   CMPIString *str=mb->eft->toString(mb,enc,&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return CmpiString(str);
}

CmpiBoolean CmpiObject::doIsA(CMPIBroker *mb, const char *typeName) const {
   CMPIStatus rc={CMPI_RC_OK,NULL};
   CmpiBoolean bv=mb->eft->isOfType(mb,enc,typeName,&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return bv;
}

//---------------------------------------------------
//--
//	CmpiEnumeration member functions
//--
//---------------------------------------------------

CmpiEnumeration::CmpiEnumeration(CMPIEnumeration* newEnc) {
   this->enc=newEnc;
}

CMPIEnumeration *CmpiEnumeration::getEnc() const {
   return (CMPIEnumeration*)this->enc;
}

CmpiEnumeration::CmpiEnumeration() {
}

CmpiBoolean CmpiEnumeration::hasNext() {
   CMPIStatus rc={CMPI_RC_OK,NULL};
   CmpiBoolean bv=getEnc()->ft->hasNext(getEnc(),&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return bv;
}

CmpiData CmpiEnumeration::getNext() {
   CMPIStatus rc={CMPI_RC_OK,NULL};
   CMPIData d=getEnc()->ft->getNext(getEnc(),&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return CmpiData(d);
}

CmpiData CmpiEnumeration::toArray() {
   CMPIStatus rc={CMPI_RC_OK,NULL};
   CMPIArray* a=getEnc()->ft->toArray(getEnc(),&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return CmpiData(CmpiArray(a));
}


//---------------------------------------------------
//--
//	CmpiContext member functions
//--
//---------------------------------------------------



const char *CmpiContext::invocationFlags=CMPIInvocationFlags;

CmpiContext::CmpiContext() {
}

CmpiContext::CmpiContext(CMPIContext* c)
         : CmpiObject((void*)c) {
}

CMPIContext *CmpiContext::getEnc() const {
   return (CMPIContext*)enc;
}

CmpiData CmpiContext::getEntry(const char* name) const{
   CmpiData d;
   CMPIStatus rc={CMPI_RC_OK,NULL};
   d._data=getEnc()->ft->getEntry(getEnc(),name,&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return CmpiData (d);
}


//---------------------------------------------------
//--
//	CmpiSelectExp member functions
//--
//---------------------------------------------------


CmpiSelectExp::CmpiSelectExp(const CMPISelectExp* newEnc) {
   this->enc=(void*)newEnc;
}

CMPISelectExp *CmpiSelectExp::getEnc() const {
   return (CMPISelectExp*)this->enc;
}

CmpiSelectExp::CmpiSelectExp() {
}



//---------------------------------------------------
//--
//	CmpiDateTime member functions
//--
//---------------------------------------------------

   /** Constructor from CMPI type
   */
CmpiDateTime::CmpiDateTime(const CMPIDateTime* newEnc) {
   this->enc=(void*)newEnc;
}

CmpiDateTime::CmpiDateTime() {
   this->enc=makeDateTime(CmpiProviderBase::getBroker());
}

CmpiDateTime::CmpiDateTime(const CmpiDateTime& original)
    : CmpiObject(0) {
   enc=makeDateTime(CmpiProviderBase::getBroker(),
                    ((CmpiDateTime&)original).getDateTime(),
                    ((CmpiDateTime&)original).isInterval());
}

CmpiDateTime::CmpiDateTime(const char* utcTime) {
   enc=makeDateTime(CmpiProviderBase::getBroker(),utcTime);
}

CmpiDateTime::CmpiDateTime(const CMPIUint64 binTime, const CmpiBoolean interval) {
   enc=makeDateTime(CmpiProviderBase::getBroker(),binTime,interval);
}

CMPIDateTime *CmpiDateTime::getEnc() const {
   return (CMPIDateTime*)enc;
}

void *CmpiDateTime::makeDateTime(CMPIBroker *mb) {
   CMPIStatus rc={CMPI_RC_OK,NULL};
   void *dt=mb->eft->newDateTime(mb,&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return dt;
}

void *CmpiDateTime::makeDateTime(CMPIBroker *mb, const char* utcTime) {
   CMPIStatus rc={CMPI_RC_OK,NULL};
   void *dt=mb->eft->newDateTimeFromChars(mb,(char*)utcTime,&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return dt;
}

void *CmpiDateTime::makeDateTime(CMPIBroker *mb, const CMPIUint64 binTime,
                                 const CmpiBoolean interval) {
   CMPIStatus rc={CMPI_RC_OK,NULL};
   void *dt=mb->eft->newDateTimeFromBinary(mb,binTime,interval,&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return dt;
}

CmpiBoolean CmpiDateTime::isInterval() const{
   CMPIStatus rc={CMPI_RC_OK,NULL};
   CmpiBoolean bv=getEnc()->ft->isInterval(getEnc(),&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return bv;
}

CMPIUint64 CmpiDateTime::getDateTime() const{
   CMPIStatus rc={CMPI_RC_OK,NULL};
   CMPIUint64 rv=getEnc()->ft->getBinaryFormat(getEnc(),&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return rv;
};


CmpiBooleanData CmpiTrue(true);
CmpiBooleanData CmpiFalse(false);

//-----------------------------------------------------------
//--
//      ProviderBase
//--
//-----------------------------------------------------------

#ifdef CMPI_VER_200
static  CMPIBroker __providerBaseBroker = {0,0,0,0,0};
#elif CMPI_VER_100
static  CMPIBroker __providerBaseBroker = {0,0,0,0};
#else
static CMPIBroker __providerBaseBroker = {0,0,0};
#endif

CmpiProviderBase::CmpiProviderBase() {
  useCount=0;
  baseMI=0;
}

CmpiProviderBase::~CmpiProviderBase() {
}

void CmpiProviderBase::
  incUseCount()
{
  useCount++;
}

int CmpiProviderBase::
  decUseCount()
{
  return --useCount;
}

void CmpiProviderBase::
  setBaseMI(CmpiBaseMI* aBaseMI)
{
  baseMI = aBaseMI;
}

CmpiBaseMI* CmpiProviderBase::
   getBaseMI()
{
  return baseMI;
}

CMPIBroker* CmpiProviderBase::
   getBroker()
{
  return &__providerBaseBroker;
}

void CmpiProviderBase::
    setBroker(const CMPIBroker *mb)
{
  if (mb) {
    __providerBaseBroker.hdl = mb->hdl;
    __providerBaseBroker.bft = mb->bft;
    __providerBaseBroker.eft = mb->eft;
  }
}