cmpiimpl.cpp

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

//--
//---------------------------------------------------

CmpiData::CmpiData(const CMPIData& data) {
   this->_data=data;
}

CmpiData::CmpiData() {
   _data.state=CMPI_nullValue;
   _data.value.uint64=0;
   _data.type=CMPI_null;
}

CmpiData::CmpiData(CMPISint8 d) {
   _data.state=CMPI_goodValue;
   _data.value.sint8=d;
   _data.type=CMPI_sint8;
}

CmpiData::CmpiData(CMPISint16 d) {
   _data.state=CMPI_goodValue;
   _data.value.sint16=d;
   _data.type=CMPI_sint16;
}

CmpiData::CmpiData(CMPISint32 d) {
   _data.state=CMPI_goodValue;
   _data.value.sint32=d;
   _data.type=CMPI_sint32;
}

CmpiData::CmpiData(CMPISint64 d) {
   _data.state=CMPI_goodValue;
   _data.value.sint64=d;
   _data.type=CMPI_sint64;
}

CmpiData::CmpiData(CMPIUint8 d) {
   _data.state=CMPI_goodValue;
   _data.value.uint8=d;
   _data.type=CMPI_uint8;
}

CmpiData::CmpiData(CMPIUint16 d) {
   _data.state=CMPI_goodValue;
   _data.value.uint16=d;
   _data.type=CMPI_uint16;
}

CmpiData::CmpiData(CMPIUint32 d) {
   _data.state=CMPI_goodValue;
   _data.value.uint32=d;
   _data.type=CMPI_uint32;
}

CmpiData::CmpiData(CMPIUint64 d) {
   _data.state=CMPI_goodValue;
   _data.value.uint64=d;
   _data.type=CMPI_uint64;
}

CmpiData::CmpiData(CMPIReal32 d) {
   _data.state=CMPI_goodValue;
   _data.value.real32=d;
   _data.type=CMPI_real32;
}

CmpiData::CmpiData(CMPIReal64 d) {
   _data.state=CMPI_goodValue;
   _data.value.real64=d;
   _data.type=CMPI_real64;
}

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

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

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

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

CmpiData::CmpiData(const CmpiObjectPath& d) {
  _data.state=d.getEnc()==0?CMPI_nullValue:CMPI_goodValue;
  _data.value.ref=(CMPIObjectPath*)d.getEnc();
  _data.type=CMPI_ref;
}

CmpiData::CmpiData(const CmpiInstance& d) {
   _data.state=d.getEnc()==0?CMPI_nullValue:CMPI_goodValue;
   _data.value.inst=(CMPIInstance*)d.getEnc();
   _data.type=CMPI_instance;
}

CmpiData::CmpiData(const CmpiData& d) {
   _data=d._data;
}

CmpiData::~CmpiData() {
}

CmpiData& CmpiData::operator= (const CmpiData& rhs) {
   if (this == &rhs)
   {
      return *this;
   }

   _data=rhs._data;

   return *this;
}

#ifdef PEGASUS_CMPI_DATA_NEED_IMPLICIT_CONVERTERS

CmpiData::operator CmpiString() const {
   if (_data.type!=CMPI_string)
     throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return CmpiString(_data.value.string);
}

CmpiData::operator const char* () const {
   if (_data.type!=CMPI_string)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return CmpiString(_data.value.string).charPtr();
}

CmpiData::operator CmpiDateTime() const {
   if (_data.type!=CMPI_dateTime)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return CmpiDateTime(_data.value.dateTime);
}

CmpiData::operator CMPISint8() const {
   if (_data.type!=CMPI_sint8)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.sint8;
}
CmpiData::operator CMPISint16() const {
   if (_data.type!=CMPI_sint16)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.sint16;
}

CmpiData::operator CMPISint32() const {
   if (_data.type!=CMPI_sint32)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.sint32;
}

CmpiData::operator CMPISint64() const {
   if (_data.type!=CMPI_sint64)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.sint64;
}

CmpiData::operator unsigned char() const {
   if (_data.type!=CMPI_uint8 && _data.type!=CMPI_boolean)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   if (_data.type==CMPI_uint8)
      return _data.value.uint8;
   else
      return _data.value.boolean;
}

CmpiData::operator unsigned short() const {
   if (_data.type!=CMPI_uint16 && _data.type!=CMPI_char16)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   if (_data.type==CMPI_uint16)
      return _data.value.uint16;
   else
      return _data.value.char16;
}

CmpiData::operator CMPIUint32() const {
   if (_data.type!=CMPI_uint32)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.uint32;
}

CmpiData::operator CMPIUint64() const {
   if (_data.type!=CMPI_uint64)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.uint64;
}

CmpiData::operator CMPIReal32() const {
   if (_data.type!=CMPI_real32)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.real32;
}

CmpiData::operator CMPIReal64() const {
   if (_data.type!=CMPI_real64)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.real64;
}

CmpiData::operator CmpiInstance() const{
   if (_data.type!=CMPI_instance)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else return CmpiInstance(_data.value.inst);
}

CmpiData::operator CmpiObjectPath() const {
   if (_data.type!=CMPI_ref)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else return CmpiObjectPath(_data.value.ref);
}

CmpiData::operator CmpiArray() const {
   if (!(_data.type&CMPI_ARRAY))
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else return CmpiArray(_data.value.array);
}

#endif /* PEGASUS_CMPI_DATA_NEED_IMPLICIT_CONVERTERS */

//==============================================================================
//
// Getters:
//
//==============================================================================

CMPIBoolean CmpiData::getBoolean() const
{
   if (_data.type != CMPI_boolean)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.boolean;
}

CMPIUint8 CmpiData::getUint8() const
{
   if (_data.type != CMPI_uint8)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.uint8;
}

CMPISint8 CmpiData::getSint8() const
{
   if (_data.type != CMPI_sint8)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.sint8;
}

CMPIUint16 CmpiData::getUint16() const
{
   if (_data.type != CMPI_uint16)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.uint16;
}

CMPISint16 CmpiData::getSint16() const
{
   if (_data.type != CMPI_sint16)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.sint16;
}

CMPIUint32 CmpiData::getUint32() const
{
   if (_data.type != CMPI_uint32)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.uint32;
}

CMPISint32 CmpiData::getSint32() const
{
   if (_data.type != CMPI_sint32)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.sint32;
}

CMPIUint64 CmpiData::getUint64() const
{
   if (_data.type != CMPI_uint64)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.uint64;
}

CMPISint64 CmpiData::getSint64() const
{
   if (_data.type != CMPI_sint64)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.sint64;
}

CMPIReal32 CmpiData::getReal32() const
{
   if (_data.type != CMPI_real32)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.real32;
}

CMPIReal64 CmpiData::getReal64() const
{
   if (_data.type != CMPI_real64)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.real64;
}

CMPIChar16 CmpiData::getChar16() const
{
   if (_data.type != CMPI_char16)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return _data.value.char16;
}

CmpiString CmpiData::getString() const
{
   if (_data.type != CMPI_string)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return CmpiString(_data.value.string);
}

const char* CmpiData::getCString() const
{
   if (_data.type!=CMPI_string)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return CMGetCharPtr(_data.value.string);
}

CmpiDateTime CmpiData::getDateTime() const
{
   if (_data.type != CMPI_dateTime)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
      return CmpiDateTime(_data.value.dateTime);
}

CmpiArray CmpiData::getArray() const
{
   if (!(_data.type & CMPI_ARRAY))
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
       return CmpiArray(_data.value.array);
}

CmpiInstance CmpiData::getInstance() const
{
   if (_data.type != CMPI_instance)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
       return CmpiInstance(_data.value.inst);
}

CmpiObjectPath CmpiData::getObjectPath() const
{
   if (_data.type != CMPI_ref)
      throw CmpiStatus(CMPI_RC_ERR_TYPE_MISMATCH);
   else
       return CmpiObjectPath(_data.value.ref);
}

//==============================================================================
//
// Setters:
//
//==============================================================================

void CmpiData::setBoolean (const CmpiBoolean d)
{
   _data.state=CMPI_goodValue;
   _data.value.boolean=d;
   _data.type=CMPI_boolean;
}

void CmpiData::setSint8 (const CMPISint8 d)
{
   _data.state=CMPI_goodValue;
   _data.value.sint8=d;
   _data.type=CMPI_sint8;
}

void CmpiData::setUint8 (const CMPIUint8 d)
{
   _data.state=CMPI_goodValue;
   _data.value.uint8=d;
   _data.type=CMPI_uint8;
}

void CmpiData::setSint16 (const CMPISint16 d)
{
   _data.state=CMPI_goodValue;
   _data.value.sint16=d;
   _data.type=CMPI_sint16;
}

void CmpiData::setUint16 (const CMPIUint16 d)
{
   _data.state=CMPI_goodValue;
   _data.value.uint16=d;
   _data.type=CMPI_uint16;
}

void CmpiData::setSint32 (const CMPISint32 d)
{
   _data.state=CMPI_goodValue;
   _data.value.sint32=d;
   _data.type=CMPI_sint32;
}

void CmpiData::setUint32 (const CMPIUint32 d)
{
   _data.state=CMPI_goodValue;
   _data.value.uint32=d;
   _data.type=CMPI_uint32;
}

void CmpiData::setSint64 (const CMPISint64 d)
{
   _data.state=CMPI_goodValue;
   _data.value.sint64=d;
   _data.type=CMPI_sint64;
}

void CmpiData::setReal32 (const CMPIReal32 d)
{
   _data.state=CMPI_goodValue;
   _data.value.real32=d;
   _data.type=CMPI_real32;
}

void CmpiData::setReal64 (const CMPIReal64 d)
{
   _data.state=CMPI_goodValue;
   _data.value.real64=d;
   _data.type=CMPI_real64;
}

void CmpiData::setChar16 (const CMPIChar16 d)
{
   _data.state=CMPI_goodValue;
   _data.value.char16=d;
   _data.type=CMPI_char16;
}