cmpiimpl.cpp

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

void CmpiData::setString (const CmpiString d)
{
   _data.state=CMPI_goodValue;
   _data.value.chars=(char*)d.charPtr();
   _data.type=CMPI_chars;
}

void CmpiData::setCString (const char* d)
{
   _data.state=CMPI_goodValue;
   _data.value.chars=(char*)d;
   _data.type=CMPI_chars;
}

void CmpiData::setDateTime (const CmpiDateTime d)
{
   _data.state=CMPI_goodValue;
   _data.value.dateTime=d.getEnc();
   _data.type=CMPI_dateTime;
}

void CmpiData::setArray (const CmpiArray d)
{
   _data.state=CMPI_goodValue;
   _data.value.array=d.getEnc();
   _data.type=((CMPIArrayFT*)d.getEnc()->ft)->getSimpleType(d.getEnc(),0) | CMPI_ARRAY;
}

void CmpiData::setInstance (const CmpiInstance d)
{
   _data.state=CMPI_goodValue;
   _data.value.inst=d.getEnc();
   _data.type=CMPI_instance;
}

void CmpiData::setObjectPath (const CmpiObjectPath d)
{
   _data.state=CMPI_goodValue;
   _data.value.ref=d.getEnc();
   _data.type=CMPI_ref;
}

////////////////////////////////////////////////////////////////////////////////

int CmpiData::isNullValue() const {
  return (_data.state & CMPI_nullValue);
}

int CmpiData::isNotFound() const {
  return (_data.state & CMPI_notFound);
}


//---------------------------------------------------
//--
//	CmpiBooleanData member functions
//--
//---------------------------------------------------

CmpiBooleanData::CmpiBooleanData(CMPIBoolean d) {
   _data.state=CMPI_goodValue;
   _data.value.boolean=d;
   _data.type=CMPI_boolean;
}


//---------------------------------------------------
//--
//	CmpiCharData member functions
//--
//---------------------------------------------------

CmpiCharData::CmpiCharData(CMPIChar16 d) {
   _data.state=CMPI_goodValue;
   _data.value.char16=d;
   _data.type=CMPI_char16;
}


//---------------------------------------------------
//--
//	CmpiInstance member functions
//--
//---------------------------------------------------

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

CMPIInstance *CmpiInstance::getEnc() const {
   return (CMPIInstance*)this->enc;
}

CmpiInstance::CmpiInstance() {
}

CmpiInstance::CmpiInstance(const CmpiObjectPath& op) {
   enc=makeInstance(CmpiProviderBase::getBroker(),op);
}

CmpiBoolean CmpiInstance::instanceIsA(const char *className) {
   return doInstanceIsA(CmpiProviderBase::getBroker(),className);
}

void *CmpiInstance::makeInstance(CMPIBroker *mb, const CmpiObjectPath& cop) {
   CMPIStatus rc={CMPI_RC_OK,NULL};


   void *inst=mb->eft->newInstance(mb,((CmpiObjectPath&)cop).getEnc(),&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);

   return inst;
}

CmpiBoolean CmpiInstance::doInstanceIsA(CMPIBroker *mb, const char *className) {
   CmpiObjectPath cop=getObjectPath();
   return cop.doClassPathIsA(mb,className);
}

CmpiData CmpiInstance::getProperty(const char* name) const{
   CmpiData d;
   CMPIStatus rc={CMPI_RC_OK,NULL};
   d._data=getEnc()->ft->getProperty(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);
}

CmpiData CmpiInstance::getProperty(const int pos, CmpiString *name) {
   CmpiData d;
   CMPIStatus rc={CMPI_RC_OK,NULL};
   CMPIString *s;
   d._data=getEnc()->ft->getPropertyAt(getEnc(),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);
};

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

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


static const char * _nullkeys[] = {0};

void CmpiInstance::setPropertyFilter(const char** properties, const char** keys) {
  if (keys==0) keys = _nullkeys;
  CMPIStatus rc=getEnc()->ft->setPropertyFilter(getEnc(),properties,
						 keys);
  if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
}

CmpiObjectPath CmpiInstance::getObjectPath() const {
   CMPIStatus rc={CMPI_RC_OK,NULL};
   CmpiObjectPath cop((CMPIObjectPath*)getEnc()->ft->getObjectPath(getEnc(),&rc));
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return cop;
}


//---------------------------------------------------
//--
//	CmpiStatus member functions
//--
//---------------------------------------------------

CMPIStatus CmpiStatus::status() const {
   return st;
}
CmpiStatus::CmpiStatus(const CMPIrc rcp, const char *msg) {
   st.rc=rcp;
   st.msg=CMNewString(CmpiProviderBase::getBroker(),(char*)msg,NULL);
}

CMPIrc CmpiStatus::rc() const {
   return st.rc;
}

const char*  CmpiStatus::msg() const {
   return st.msg ? CMGetCharPtr(st.msg) : 0;
}

CmpiStatus::CmpiStatus() {
   st.rc=CMPI_RC_OK;
   st.msg=NULL;
}

CmpiStatus::CmpiStatus(const CMPIrc rcp) {
   st.rc=rcp;
   st.msg=NULL;
}

CmpiStatus::CmpiStatus(const CMPIStatus stat) {
   st=stat;
}

//---------------------------------------------------
//--
//	CmpiObjectPath member functions
//--
//---------------------------------------------------

CmpiObjectPath::CmpiObjectPath(const char *ns, const char *cls) {
   enc=makeObjectPath(CmpiProviderBase::getBroker(),ns,cls);
}

CmpiObjectPath::CmpiObjectPath(const CmpiString &ns, const char *cls) {
   enc=makeObjectPath(CmpiProviderBase::getBroker(),ns,cls);
}

CmpiObjectPath::CmpiObjectPath(CMPIObjectPath* c)
     : CmpiObject((void*)c) {
}

CMPIObjectPath *CmpiObjectPath::getEnc() const {
   return (CMPIObjectPath*)enc;
}

CmpiBoolean CmpiObjectPath::classPathIsA(const char *className) const {
   return doClassPathIsA(CmpiProviderBase::getBroker(),className);
}

void CmpiObjectPath::setHostname(CmpiString hn) {
   setHostname(hn.charPtr());
}

void CmpiObjectPath::setNameSpace(CmpiString ns) {
   setNameSpace(ns.charPtr());
}

void CmpiObjectPath::setClassName(CmpiString hn) {
   setClassName(hn.charPtr());
}

void *CmpiObjectPath::makeObjectPath(CMPIBroker *mb, const char *ns, const char *cls) {
   CMPIStatus rc={CMPI_RC_OK,NULL};
   void *op=mb->eft->newObjectPath(mb,ns,cls,&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return op;
}

void *CmpiObjectPath::makeObjectPath(CMPIBroker *mb, const CmpiString& ns, const char *cls) {
   CMPIStatus rc={CMPI_RC_OK,NULL};
   void *op=mb->eft->newObjectPath(mb,CMGetCharPtr(ns.getEnc()),cls,&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return op;
}

CmpiBoolean CmpiObjectPath::doClassPathIsA(CMPIBroker *mb, const char *className) const {
   CMPIStatus rc = {CMPI_RC_OK,NULL};
   CmpiBoolean bv=mb->eft->classPathIsA(mb,getEnc(),className,&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return bv;
}

CmpiString CmpiObjectPath::getNameSpace() const{
   CMPIStatus rc={CMPI_RC_OK,NULL};
   CMPIString *s=getEnc()->ft->getNameSpace(getEnc(),&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return CmpiString(s);
}

void CmpiObjectPath::setNameSpace(const char* ns) {
   CMPIStatus rc=getEnc()->ft->setNameSpace(getEnc(),ns);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
}

CmpiString CmpiObjectPath::getHostname() const {
   CMPIStatus rc={CMPI_RC_OK,NULL};
   CMPIString *s=getEnc()->ft->getHostname(getEnc(),&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return CmpiString(s);
}

void CmpiObjectPath::setHostname(const char* hn) {
   CMPIStatus rc=getEnc()->ft->setHostname(getEnc(),hn);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
}

CmpiString CmpiObjectPath::getClassName() const {
   CMPIStatus rc={CMPI_RC_OK,NULL};
   CMPIString *s=getEnc()->ft->getClassName(getEnc(),&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return CmpiString(s);
}

void CmpiObjectPath::setClassName(const char* cn) {
   CMPIStatus rc=getEnc()->ft->setClassName(getEnc(),cn);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
}

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

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

CmpiData CmpiObjectPath::getKey(const int pos, CmpiString *name) const{
   CmpiData d;
   CMPIStatus rc={CMPI_RC_OK,NULL};
   CMPIString *s;
   d._data=getEnc()->ft->getKeyAt(getEnc(),(int)pos,&s,&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   if (name) *name=CmpiString(s);
   return CmpiData (d);
}

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


//---------------------------------------------------
//--
//	CmpiResult member functions
//--
//---------------------------------------------------

CmpiResult::CmpiResult() {
}

CmpiResult::CmpiResult(CMPIResult* r)
      : CmpiObject((void*)r) {
}

CMPIResult *CmpiResult::getEnc() const {
   return (CMPIResult*)enc;
}

void CmpiResult::returnData(const CmpiData& d) {
  CMPIStatus rc=getEnc()->ft->returnData(getEnc(),
   d._data.type!=CMPI_chars ? &d._data.value : (CMPIValue*)d._data.value.chars,
   d._data.type);
  if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
}

void CmpiResult::returnData(const CmpiInstance& d) {
   CMPIStatus rc=getEnc()->ft->returnInstance(getEnc(),d.getEnc());
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
}

void CmpiResult::returnData(const CmpiObjectPath& d) {
   CMPIStatus rc=getEnc()->ft->returnObjectPath(getEnc(),d.getEnc());
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
}

void CmpiResult::returnDone() {
   CMPIStatus rc=getEnc()->ft->returnDone(getEnc());
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
}



//---------------------------------------------------
//--
//	CmpiBroker member functions
//--
//---------------------------------------------------

CmpiBroker::CmpiBroker(CMPIBroker* b)
         : CmpiObject((void*)b) {
}

CMPIBroker *CmpiBroker::getEnc() const {
   return (CMPIBroker*)enc;
}

CmpiContext CmpiBroker::prepareAttachThread(const CmpiContext& ctx)
{
  CMPIContext* cctx=
    getEnc()->bft->prepareAttachThread(getEnc(),ctx.getEnc());
  return CmpiContext(cctx);
}

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

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


void CmpiBroker::deliverIndication(const CmpiContext& ctx, const char* ns,
                                   const CmpiInstance& inst)
{
  CMPIStatus rc=
    getEnc()->bft->deliverIndication(getEnc(),ctx.getEnc(),ns,inst.getEnc());
  if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
}

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

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


     // class 2 services
CmpiObjectPath CmpiBroker::createInstance(const CmpiContext& ctx,
                              const CmpiObjectPath& cop,
                              const CmpiInstance& inst)
{
   CMPIStatus rc={CMPI_RC_OK,NULL};
   CMPIObjectPath* co=getEnc()->bft->createInstance
     (getEnc(),ctx.getEnc(),cop.getEnc(),inst.getEnc(),&rc);
   if (rc.rc!=CMPI_RC_OK) throw CmpiStatus(rc);
   return CmpiObjectPath(co);
}

void CmpiBroker::setInstance(const CmpiContext& ctx, const CmpiObjectPath& cop,
                             const CmpiInstance& inst, const char** properties)
{
#ifdef CMPI_VER_100
   CMPIStatus rc=getEnc()->bft->modifyInstance
     (getEnc(),ctx.getEnc(),cop.getEnc(),inst.getEnc(), properties);
#else
   CMPIStatus rc=getEnc()->bft->setInstance
     (getEnc(),ctx.getEnc(),cop.getEnc(),inst.getEnc(), properties);
#endif