(file) Return to CIMValue.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/CIMValue.cpp between version 1.35 and 1.37

version 1.35, 2002/07/19 18:47:11 version 1.37, 2002/08/16 01:28:06
Line 25 
Line 25 
 // //
 // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 //              Karl Schopmeyer, (k.schopmeyer@opengroup.org) //              Karl Schopmeyer, (k.schopmeyer@opengroup.org)
   //              Carol Ann Krug Graves, Hewlett-Packard Company
   //                (carolann_graves@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 116 
Line 118 
  
     void reset()     void reset()
     {     {
         _type = CIMType::NONE;          _type = CIMTYPE_NONE;
         _isArray = false;         _isArray = false;
         _isNull = true;         _isNull = true;
         _u._voidPtr = 0;         _u._voidPtr = 0;
Line 360 
Line 362 
     {     {
         switch (_rep->_type)         switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 _rep->_u._booleanArray =                 _rep->_u._booleanArray =
                     new Array<Boolean>(*(x._rep->_u._booleanArray));                     new Array<Boolean>(*(x._rep->_u._booleanArray));
                 break;                 break;
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 _rep->_u._uint8Array =                 _rep->_u._uint8Array =
                     new Array<Uint8>(*(x._rep->_u._uint8Array));                     new Array<Uint8>(*(x._rep->_u._uint8Array));
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 _rep->_u._sint8Array =                 _rep->_u._sint8Array =
                     new Array<Sint8>(*(x._rep->_u._sint8Array));                     new Array<Sint8>(*(x._rep->_u._sint8Array));
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 _rep->_u._uint16Array =                 _rep->_u._uint16Array =
                     new Array<Uint16>(*(x._rep->_u._uint16Array));                     new Array<Uint16>(*(x._rep->_u._uint16Array));
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 _rep->_u._sint16Array =                 _rep->_u._sint16Array =
                     new Array<Sint16>(*(x._rep->_u._sint16Array));                     new Array<Sint16>(*(x._rep->_u._sint16Array));
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 _rep->_u._uint32Array =                 _rep->_u._uint32Array =
                     new Array<Uint32>(*(x._rep->_u._uint32Array));                     new Array<Uint32>(*(x._rep->_u._uint32Array));
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 _rep->_u._sint32Array =                 _rep->_u._sint32Array =
                     new Array<Sint32>(*(x._rep->_u._sint32Array));                     new Array<Sint32>(*(x._rep->_u._sint32Array));
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 _rep->_u._uint64Array =                 _rep->_u._uint64Array =
                     new Array<Uint64>(*(x._rep->_u._uint64Array));                     new Array<Uint64>(*(x._rep->_u._uint64Array));
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 _rep->_u._sint64Array =                 _rep->_u._sint64Array =
                     new Array<Sint64>(*(x._rep->_u._sint64Array));                     new Array<Sint64>(*(x._rep->_u._sint64Array));
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 _rep->_u._real32Array =                 _rep->_u._real32Array =
                     new Array<Real32>(*(x._rep->_u._real32Array));                     new Array<Real32>(*(x._rep->_u._real32Array));
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 _rep->_u._real64Array =                 _rep->_u._real64Array =
                     new Array<Real64>(*(x._rep->_u._real64Array));                     new Array<Real64>(*(x._rep->_u._real64Array));
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 _rep->_u._char16Array =                 _rep->_u._char16Array =
                     new Array<Char16>(*(x._rep->_u._char16Array));                     new Array<Char16>(*(x._rep->_u._char16Array));
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 _rep->_u._stringArray =                 _rep->_u._stringArray =
                     new Array<String>(*(x._rep->_u._stringArray));                     new Array<String>(*(x._rep->_u._stringArray));
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 _rep->_u._dateTimeArray =                 _rep->_u._dateTimeArray =
                     new Array<CIMDateTime>(*(x._rep->_u._dateTimeArray));                     new Array<CIMDateTime>(*(x._rep->_u._dateTimeArray));
                 break;                 break;
  
             case CIMType::REFERENCE:              case CIMTYPE_REFERENCE:
                 _rep->_u._referenceArray =                 _rep->_u._referenceArray =
                     new Array<CIMObjectPath>(*(x._rep->_u._referenceArray));                     new Array<CIMObjectPath>(*(x._rep->_u._referenceArray));
                 break;                 break;
Line 442 
Line 444 
     {     {
         switch (_rep->_type)         switch (_rep->_type)
         {         {
             case CIMType::NONE:              case CIMTYPE_NONE:
                 break;                 break;
  
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 _rep->_u._booleanValue = x._rep->_u._booleanValue;                 _rep->_u._booleanValue = x._rep->_u._booleanValue;
                 break;                 break;
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 _rep->_u._uint8Value = x._rep->_u._uint8Value;                 _rep->_u._uint8Value = x._rep->_u._uint8Value;
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 _rep->_u._sint8Value = x._rep->_u._sint8Value;                 _rep->_u._sint8Value = x._rep->_u._sint8Value;
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 _rep->_u._uint16Value = x._rep->_u._uint16Value;                 _rep->_u._uint16Value = x._rep->_u._uint16Value;
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 _rep->_u._sint16Value = x._rep->_u._sint16Value;                 _rep->_u._sint16Value = x._rep->_u._sint16Value;
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 _rep->_u._uint32Value = x._rep->_u._uint32Value;                 _rep->_u._uint32Value = x._rep->_u._uint32Value;
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 _rep->_u._sint32Value = x._rep->_u._sint32Value;                 _rep->_u._sint32Value = x._rep->_u._sint32Value;
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 _rep->_u._uint64Value = x._rep->_u._uint64Value;                 _rep->_u._uint64Value = x._rep->_u._uint64Value;
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 _rep->_u._sint64Value = x._rep->_u._sint64Value;                 _rep->_u._sint64Value = x._rep->_u._sint64Value;
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 _rep->_u._real32Value = x._rep->_u._real32Value;                 _rep->_u._real32Value = x._rep->_u._real32Value;
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 _rep->_u._real64Value = x._rep->_u._real64Value;                 _rep->_u._real64Value = x._rep->_u._real64Value;
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 _rep->_u._char16Value = x._rep->_u._char16Value;                 _rep->_u._char16Value = x._rep->_u._char16Value;
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 _rep->_u._stringValue = new String(*(x._rep->_u._stringValue));                 _rep->_u._stringValue = new String(*(x._rep->_u._stringValue));
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 _rep->_u._dateTimeValue =                 _rep->_u._dateTimeValue =
                     new CIMDateTime(*(x._rep->_u._dateTimeValue));                     new CIMDateTime(*(x._rep->_u._dateTimeValue));
                 break;                 break;
  
             case CIMType::REFERENCE:              case CIMTYPE_REFERENCE:
                 _rep->_u._referenceValue =                 _rep->_u._referenceValue =
                     new CIMObjectPath(*(x._rep->_u._referenceValue));                     new CIMObjectPath(*(x._rep->_u._referenceValue));
                 break;                 break;
Line 523 
Line 525 
     {     {
         switch (_rep->_type)         switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 delete _rep->_u._booleanArray;                 delete _rep->_u._booleanArray;
                 break;                 break;
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 delete _rep->_u._uint8Array;                 delete _rep->_u._uint8Array;
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 delete _rep->_u._sint8Array;                 delete _rep->_u._sint8Array;
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 delete _rep->_u._uint16Array;                 delete _rep->_u._uint16Array;
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 delete _rep->_u._sint16Array;                 delete _rep->_u._sint16Array;
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 delete _rep->_u._uint32Array;                 delete _rep->_u._uint32Array;
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 delete _rep->_u._sint32Array;                 delete _rep->_u._sint32Array;
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 delete _rep->_u._uint64Array;                 delete _rep->_u._uint64Array;
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 delete _rep->_u._sint64Array;                 delete _rep->_u._sint64Array;
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 delete _rep->_u._real32Array;                 delete _rep->_u._real32Array;
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 delete _rep->_u._real64Array;                 delete _rep->_u._real64Array;
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 delete _rep->_u._char16Array;                 delete _rep->_u._char16Array;
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 delete _rep->_u._stringArray;                 delete _rep->_u._stringArray;
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 delete _rep->_u._dateTimeArray;                 delete _rep->_u._dateTimeArray;
                 break;                 break;
  
             case CIMType::REFERENCE:              case CIMTYPE_REFERENCE:
                 delete _rep->_u._referenceArray;                 delete _rep->_u._referenceArray;
                 break;                 break;
  
Line 591 
Line 593 
     {     {
         switch (_rep->_type)         switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
             case CIMType::UINT8:              case CIMTYPE_UINT8:
             case CIMType::SINT8:              case CIMTYPE_SINT8:
             case CIMType::UINT16:              case CIMTYPE_UINT16:
             case CIMType::SINT16:              case CIMTYPE_SINT16:
             case CIMType::UINT32:              case CIMTYPE_UINT32:
             case CIMType::SINT32:              case CIMTYPE_SINT32:
             case CIMType::UINT64:              case CIMTYPE_UINT64:
             case CIMType::SINT64:              case CIMTYPE_SINT64:
             case CIMType::REAL32:              case CIMTYPE_REAL32:
             case CIMType::REAL64:              case CIMTYPE_REAL64:
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 delete _rep->_u._stringValue;                 delete _rep->_u._stringValue;
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 delete _rep->_u._dateTimeValue;                 delete _rep->_u._dateTimeValue;
                 break;                 break;
  
             case CIMType::REFERENCE:              case CIMTYPE_REFERENCE:
                 delete _rep->_u._referenceValue;                 delete _rep->_u._referenceValue;
                 break;                 break;
             //default:             //default:
Line 648 
Line 650 
  
     switch (_rep->_type)     switch (_rep->_type)
     {     {
         case CIMType::NONE:          case CIMTYPE_NONE:
             return 0;             return 0;
             break;             break;
  
         case CIMType::BOOLEAN:          case CIMTYPE_BOOLEAN:
             return _rep->_u._booleanArray->size();             return _rep->_u._booleanArray->size();
             break;             break;
  
         case CIMType::UINT8:          case CIMTYPE_UINT8:
             return _rep->_u._uint8Array->size();             return _rep->_u._uint8Array->size();
             break;             break;
  
         case CIMType::SINT8:          case CIMTYPE_SINT8:
             return _rep->_u._sint8Array->size();             return _rep->_u._sint8Array->size();
             break;             break;
  
         case CIMType::UINT16:          case CIMTYPE_UINT16:
             return _rep->_u._uint16Array->size();             return _rep->_u._uint16Array->size();
             break;             break;
  
         case CIMType::SINT16:          case CIMTYPE_SINT16:
             return _rep->_u._sint16Array->size();             return _rep->_u._sint16Array->size();
             break;             break;
  
         case CIMType::UINT32:          case CIMTYPE_UINT32:
             return _rep->_u._uint32Array->size();             return _rep->_u._uint32Array->size();
             break;             break;
  
         case CIMType::SINT32:          case CIMTYPE_SINT32:
             return _rep->_u._sint32Array->size();             return _rep->_u._sint32Array->size();
             break;             break;
  
         case CIMType::UINT64:          case CIMTYPE_UINT64:
             return _rep->_u._uint64Array->size();             return _rep->_u._uint64Array->size();
             break;             break;
  
         case CIMType::SINT64:          case CIMTYPE_SINT64:
             return _rep->_u._sint64Array->size();             return _rep->_u._sint64Array->size();
             break;             break;
  
         case CIMType::REAL32:          case CIMTYPE_REAL32:
             return _rep->_u._real32Array->size();             return _rep->_u._real32Array->size();
             break;             break;
  
         case CIMType::REAL64:          case CIMTYPE_REAL64:
             return _rep->_u._real64Array->size();             return _rep->_u._real64Array->size();
             break;             break;
  
         case CIMType::CHAR16:          case CIMTYPE_CHAR16:
             return _rep->_u._char16Array->size();             return _rep->_u._char16Array->size();
             break;             break;
  
         case CIMType::STRING:          case CIMTYPE_STRING:
             return _rep->_u._stringArray->size();             return _rep->_u._stringArray->size();
             break;             break;
  
         case CIMType::DATETIME:          case CIMTYPE_DATETIME:
             return _rep->_u._dateTimeArray->size();             return _rep->_u._dateTimeArray->size();
             break;             break;
  
         case CIMType::REFERENCE:          case CIMTYPE_REFERENCE:
             return _rep->_u._referenceArray->size();             return _rep->_u._referenceArray->size();
             break;             break;
         // Should never get here. switch on complete enum         // Should never get here. switch on complete enum
Line 735 
Line 737 
     {     {
         switch (type)         switch (type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 set(Array<Boolean>(arraySize));                 set(Array<Boolean>(arraySize));
                 break;                 break;
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 set(Array<Uint8>(arraySize));                 set(Array<Uint8>(arraySize));
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 set(Array<Sint8>(arraySize));                 set(Array<Sint8>(arraySize));
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 set(Array<Uint16>(arraySize));                 set(Array<Uint16>(arraySize));
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 set(Array<Sint16>(arraySize));                 set(Array<Sint16>(arraySize));
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 set(Array<Uint32>(arraySize));                 set(Array<Uint32>(arraySize));
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 set(Array<Sint32>(arraySize));                 set(Array<Sint32>(arraySize));
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 set(Array<Uint64>(arraySize));                 set(Array<Uint64>(arraySize));
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 set(Array<Sint64>(arraySize));                 set(Array<Sint64>(arraySize));
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 set(Array<Real32>(arraySize));                 set(Array<Real32>(arraySize));
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 set(Array<Real64>(arraySize));                 set(Array<Real64>(arraySize));
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 set(Array<Char16>(arraySize));                 set(Array<Char16>(arraySize));
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 set(Array<String>(arraySize));                 set(Array<String>(arraySize));
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 set(Array<CIMDateTime>(arraySize));                 set(Array<CIMDateTime>(arraySize));
                 break;                 break;
  
             case CIMType::REFERENCE:              case CIMTYPE_REFERENCE:
                 set(Array<CIMObjectPath>(arraySize));                 set(Array<CIMObjectPath>(arraySize));
                 break;                 break;
             default:             default:
Line 802 
Line 804 
     {     {
         switch (type)         switch (type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 set(false);                 set(false);
                 break;                 break;
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 set(Uint8(0));                 set(Uint8(0));
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 set(Sint8(0));                 set(Sint8(0));
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 set(Uint16(0));                 set(Uint16(0));
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 set(Sint16(0));                 set(Sint16(0));
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 set(Uint32(0));                 set(Uint32(0));
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 set(Sint32(0));                 set(Sint32(0));
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 set(Uint64(0));                 set(Uint64(0));
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 set(Sint64(0));                 set(Sint64(0));
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 set(Real32(0.0));                 set(Real32(0.0));
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 set(Real64(0.0));                 set(Real64(0.0));
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 set(Char16(0));                 set(Char16(0));
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 set(String());                 set(String());
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 set(CIMDateTime());                 set(CIMDateTime());
                 break;                 break;
  
             case CIMType::REFERENCE:              case CIMTYPE_REFERENCE:
                 set(CIMObjectPath());                 set(CIMObjectPath());
                 break;                 break;
             default:             default:
Line 876 
Line 878 
 { {
     clear();     clear();
     _rep->_u._booleanValue = (Uint8)x;     _rep->_u._booleanValue = (Uint8)x;
     _rep->_type = CIMType::BOOLEAN;      _rep->_type = CIMTYPE_BOOLEAN;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
Line 884 
Line 886 
 { {
     clear();     clear();
     _rep->_u._uint8Value = x;     _rep->_u._uint8Value = x;
     _rep->_type = CIMType::UINT8;      _rep->_type = CIMTYPE_UINT8;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
Line 892 
Line 894 
 { {
     clear();     clear();
     _rep->_u._sint8Value = x;     _rep->_u._sint8Value = x;
     _rep->_type = CIMType::SINT8;      _rep->_type = CIMTYPE_SINT8;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
Line 900 
Line 902 
 { {
     clear();     clear();
     _rep->_u._uint16Value = x;     _rep->_u._uint16Value = x;
     _rep->_type = CIMType::UINT16;      _rep->_type = CIMTYPE_UINT16;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
Line 908 
Line 910 
 { {
     clear();     clear();
     _rep->_u._sint16Value = x;     _rep->_u._sint16Value = x;
     _rep->_type = CIMType::SINT16;      _rep->_type = CIMTYPE_SINT16;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
Line 916 
Line 918 
 { {
     clear();     clear();
     _rep->_u._uint32Value = x;     _rep->_u._uint32Value = x;
     _rep->_type = CIMType::UINT32;      _rep->_type = CIMTYPE_UINT32;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
Line 924 
Line 926 
 { {
     clear();     clear();
     _rep->_u._sint32Value = x;     _rep->_u._sint32Value = x;
     _rep->_type = CIMType::SINT32;      _rep->_type = CIMTYPE_SINT32;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
Line 932 
Line 934 
 { {
     clear();     clear();
     _rep->_u._uint64Value = x;     _rep->_u._uint64Value = x;
     _rep->_type = CIMType::UINT64;      _rep->_type = CIMTYPE_UINT64;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
Line 940 
Line 942 
 { {
     clear();     clear();
     _rep->_u._sint64Value = x;     _rep->_u._sint64Value = x;
     _rep->_type = CIMType::SINT64;      _rep->_type = CIMTYPE_SINT64;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
Line 948 
Line 950 
 { {
     clear();     clear();
     _rep->_u._real32Value = x;     _rep->_u._real32Value = x;
     _rep->_type = CIMType::REAL32;      _rep->_type = CIMTYPE_REAL32;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
Line 956 
Line 958 
 { {
     clear();     clear();
     _rep->_u._real64Value = x;     _rep->_u._real64Value = x;
     _rep->_type = CIMType::REAL64;      _rep->_type = CIMTYPE_REAL64;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
Line 964 
Line 966 
 { {
     clear();     clear();
     _rep->_u._char16Value = x;     _rep->_u._char16Value = x;
     _rep->_type = CIMType::CHAR16;      _rep->_type = CIMTYPE_CHAR16;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
Line 972 
Line 974 
 { {
     clear();     clear();
     _rep->_u._stringValue = new String(x);     _rep->_u._stringValue = new String(x);
     _rep->_type = CIMType::STRING;      _rep->_type = CIMTYPE_STRING;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
Line 980 
Line 982 
 { {
     clear();     clear();
     _rep->_u._dateTimeValue = new CIMDateTime(x);     _rep->_u._dateTimeValue = new CIMDateTime(x);
     _rep->_type = CIMType::DATETIME;      _rep->_type = CIMTYPE_DATETIME;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
Line 988 
Line 990 
 { {
     clear();     clear();
     _rep->_u._referenceValue = new CIMObjectPath(x);     _rep->_u._referenceValue = new CIMObjectPath(x);
     _rep->_type = CIMType::REFERENCE;      _rep->_type = CIMTYPE_REFERENCE;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
Line 996 
Line 998 
 { {
     clear();     clear();
     _rep->_u._booleanArray = new Array<Boolean>(x);     _rep->_u._booleanArray = new Array<Boolean>(x);
     _rep->_type = CIMType::BOOLEAN;      _rep->_type = CIMTYPE_BOOLEAN;
     _rep->_isArray = true;     _rep->_isArray = true;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
Line 1005 
Line 1007 
 { {
     clear();     clear();
     _rep->_u._uint8Array = new Array<Uint8>(x);     _rep->_u._uint8Array = new Array<Uint8>(x);
     _rep->_type = CIMType::UINT8;      _rep->_type = CIMTYPE_UINT8;
     _rep->_isArray = true;     _rep->_isArray = true;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
Line 1014 
Line 1016 
 { {
     clear();     clear();
     _rep->_u._sint8Array = new Array<Sint8>(x);     _rep->_u._sint8Array = new Array<Sint8>(x);
     _rep->_type = CIMType::SINT8;      _rep->_type = CIMTYPE_SINT8;
     _rep->_isArray = true;     _rep->_isArray = true;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
Line 1023 
Line 1025 
 { {
     clear();     clear();
     _rep->_u._uint16Array = new Array<Uint16>(x);     _rep->_u._uint16Array = new Array<Uint16>(x);
     _rep->_type = CIMType::UINT16;      _rep->_type = CIMTYPE_UINT16;
     _rep->_isArray = true;     _rep->_isArray = true;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
Line 1032 
Line 1034 
 { {
     clear();     clear();
     _rep->_u._sint16Array = new Array<Sint16>(x);     _rep->_u._sint16Array = new Array<Sint16>(x);
     _rep->_type = CIMType::SINT16;      _rep->_type = CIMTYPE_SINT16;
     _rep->_isArray = true;     _rep->_isArray = true;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
Line 1041 
Line 1043 
 { {
     clear();     clear();
     _rep->_u._uint32Array = new Array<Uint32>(x);     _rep->_u._uint32Array = new Array<Uint32>(x);
     _rep->_type = CIMType::UINT32;      _rep->_type = CIMTYPE_UINT32;
     _rep->_isArray = true;     _rep->_isArray = true;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
Line 1050 
Line 1052 
 { {
     clear();     clear();
     _rep->_u._sint32Array = new Array<Sint32>(x);     _rep->_u._sint32Array = new Array<Sint32>(x);
     _rep->_type = CIMType::SINT32;      _rep->_type = CIMTYPE_SINT32;
     _rep->_isArray = true;     _rep->_isArray = true;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
Line 1059 
Line 1061 
 { {
     clear();     clear();
     _rep->_u._uint64Array = new Array<Uint64>(x);     _rep->_u._uint64Array = new Array<Uint64>(x);
     _rep->_type = CIMType::UINT64;      _rep->_type = CIMTYPE_UINT64;
     _rep->_isArray = true;     _rep->_isArray = true;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
Line 1068 
Line 1070 
 { {
     clear();     clear();
     _rep->_u._sint64Array = new Array<Sint64>(x);     _rep->_u._sint64Array = new Array<Sint64>(x);
     _rep->_type = CIMType::SINT64;      _rep->_type = CIMTYPE_SINT64;
     _rep->_isArray = true;     _rep->_isArray = true;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
Line 1077 
Line 1079 
 { {
     clear();     clear();
     _rep->_u._real32Array = new Array<Real32>(x);     _rep->_u._real32Array = new Array<Real32>(x);
     _rep->_type = CIMType::REAL32;      _rep->_type = CIMTYPE_REAL32;
     _rep->_isArray = true;     _rep->_isArray = true;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
Line 1086 
Line 1088 
 { {
     clear();     clear();
     _rep->_u._real64Array = new Array<Real64>(x);     _rep->_u._real64Array = new Array<Real64>(x);
     _rep->_type = CIMType::REAL64;      _rep->_type = CIMTYPE_REAL64;
     _rep->_isArray = true;     _rep->_isArray = true;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
Line 1095 
Line 1097 
 { {
     clear();     clear();
     _rep->_u._char16Array = new Array<Char16>(x);     _rep->_u._char16Array = new Array<Char16>(x);
     _rep->_type = CIMType::CHAR16;      _rep->_type = CIMTYPE_CHAR16;
     _rep->_isArray = true;     _rep->_isArray = true;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
Line 1104 
Line 1106 
 { {
     clear();     clear();
     _rep->_u._stringArray = new Array<String>(x);     _rep->_u._stringArray = new Array<String>(x);
     _rep->_type = CIMType::STRING;      _rep->_type = CIMTYPE_STRING;
     _rep->_isArray = true;     _rep->_isArray = true;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
Line 1113 
Line 1115 
 { {
     clear();     clear();
     _rep->_u._dateTimeArray = new Array<CIMDateTime>(x);     _rep->_u._dateTimeArray = new Array<CIMDateTime>(x);
     _rep->_type = CIMType::DATETIME;      _rep->_type = CIMTYPE_DATETIME;
     _rep->_isArray = true;     _rep->_isArray = true;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
Line 1122 
Line 1124 
 { {
     clear();     clear();
     _rep->_u._referenceArray = new Array<CIMObjectPath>(x);     _rep->_u._referenceArray = new Array<CIMObjectPath>(x);
     _rep->_type = CIMType::REFERENCE;      _rep->_type = CIMTYPE_REFERENCE;
     _rep->_isArray = true;     _rep->_isArray = true;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
 void CIMValue::get(Boolean& x) const void CIMValue::get(Boolean& x) const
 { {
     if (_rep->_type != CIMType::BOOLEAN || _rep->_isArray)      if (_rep->_type != CIMTYPE_BOOLEAN || _rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = _rep->_u._booleanValue != 0;     x = _rep->_u._booleanValue != 0;
Line 1137 
Line 1139 
  
 void CIMValue::get(Uint8& x) const void CIMValue::get(Uint8& x) const
 { {
     if (_rep->_type != CIMType::UINT8 || _rep->_isArray)      if (_rep->_type != CIMTYPE_UINT8 || _rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = _rep->_u._uint8Value;     x = _rep->_u._uint8Value;
Line 1145 
Line 1147 
  
 void CIMValue::get(Sint8& x) const void CIMValue::get(Sint8& x) const
 { {
     if (_rep->_type != CIMType::SINT8 || _rep->_isArray)      if (_rep->_type != CIMTYPE_SINT8 || _rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = _rep->_u._sint8Value;     x = _rep->_u._sint8Value;
Line 1153 
Line 1155 
  
 void CIMValue::get(Uint16& x) const void CIMValue::get(Uint16& x) const
 { {
     if (_rep->_type != CIMType::UINT16 || _rep->_isArray)      if (_rep->_type != CIMTYPE_UINT16 || _rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = _rep->_u._uint16Value;     x = _rep->_u._uint16Value;
Line 1161 
Line 1163 
  
 void CIMValue::get(Sint16& x) const void CIMValue::get(Sint16& x) const
 { {
     if (_rep->_type != CIMType::SINT16 || _rep->_isArray)      if (_rep->_type != CIMTYPE_SINT16 || _rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = _rep->_u._sint16Value;     x = _rep->_u._sint16Value;
Line 1169 
Line 1171 
  
 void CIMValue::get(Uint32& x) const void CIMValue::get(Uint32& x) const
 { {
     if (_rep->_type != CIMType::UINT32 || _rep->_isArray)      if (_rep->_type != CIMTYPE_UINT32 || _rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = _rep->_u._uint32Value;     x = _rep->_u._uint32Value;
Line 1177 
Line 1179 
  
 void CIMValue::get(Sint32& x) const void CIMValue::get(Sint32& x) const
 { {
     if (_rep->_type != CIMType::SINT32 || _rep->_isArray)      if (_rep->_type != CIMTYPE_SINT32 || _rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = _rep->_u._sint32Value;     x = _rep->_u._sint32Value;
Line 1185 
Line 1187 
  
 void CIMValue::get(Uint64& x) const void CIMValue::get(Uint64& x) const
 { {
     if (_rep->_type != CIMType::UINT64 || _rep->_isArray)      if (_rep->_type != CIMTYPE_UINT64 || _rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = _rep->_u._uint64Value;     x = _rep->_u._uint64Value;
Line 1193 
Line 1195 
  
 void CIMValue::get(Sint64& x) const void CIMValue::get(Sint64& x) const
 { {
     if (_rep->_type != CIMType::SINT64 || _rep->_isArray)      if (_rep->_type != CIMTYPE_SINT64 || _rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = _rep->_u._sint64Value;     x = _rep->_u._sint64Value;
Line 1201 
Line 1203 
  
 void CIMValue::get(Real32& x) const void CIMValue::get(Real32& x) const
 { {
     if (_rep->_type != CIMType::REAL32 || _rep->_isArray)      if (_rep->_type != CIMTYPE_REAL32 || _rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = _rep->_u._real32Value;     x = _rep->_u._real32Value;
Line 1209 
Line 1211 
  
 void CIMValue::get(Real64& x) const void CIMValue::get(Real64& x) const
 { {
     if (_rep->_type != CIMType::REAL64 || _rep->_isArray)      if (_rep->_type != CIMTYPE_REAL64 || _rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = _rep->_u._real64Value;     x = _rep->_u._real64Value;
Line 1217 
Line 1219 
  
 void CIMValue::get(Char16& x) const void CIMValue::get(Char16& x) const
 { {
     if (_rep->_type != CIMType::CHAR16 || _rep->_isArray)      if (_rep->_type != CIMTYPE_CHAR16 || _rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = _rep->_u._char16Value;     x = _rep->_u._char16Value;
Line 1225 
Line 1227 
  
 void CIMValue::get(String& x) const void CIMValue::get(String& x) const
 { {
     if (_rep->_type != CIMType::STRING || _rep->_isArray)      if (_rep->_type != CIMTYPE_STRING || _rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._stringValue;     x = *_rep->_u._stringValue;
Line 1233 
Line 1235 
  
 void CIMValue::get(CIMDateTime& x) const void CIMValue::get(CIMDateTime& x) const
 { {
     if (_rep->_type != CIMType::DATETIME || _rep->_isArray)      if (_rep->_type != CIMTYPE_DATETIME || _rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._dateTimeValue;     x = *_rep->_u._dateTimeValue;
Line 1241 
Line 1243 
  
 void CIMValue::get(CIMObjectPath& x) const void CIMValue::get(CIMObjectPath& x) const
 { {
     if (_rep->_type != CIMType::REFERENCE || _rep->_isArray)      if (_rep->_type != CIMTYPE_REFERENCE || _rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._referenceValue;     x = *_rep->_u._referenceValue;
Line 1249 
Line 1251 
  
 void CIMValue::get(Array<Boolean>& x) const void CIMValue::get(Array<Boolean>& x) const
 { {
     if (_rep->_type != CIMType::BOOLEAN || !_rep->_isArray)      if (_rep->_type != CIMTYPE_BOOLEAN || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._booleanArray;     x = *_rep->_u._booleanArray;
Line 1257 
Line 1259 
  
 void CIMValue::get(Array<Uint8>& x) const void CIMValue::get(Array<Uint8>& x) const
 { {
     if (_rep->_type != CIMType::UINT8 || !_rep->_isArray)      if (_rep->_type != CIMTYPE_UINT8 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._uint8Array;     x = *_rep->_u._uint8Array;
Line 1265 
Line 1267 
  
 void CIMValue::get(Array<Sint8>& x) const void CIMValue::get(Array<Sint8>& x) const
 { {
     if (_rep->_type != CIMType::SINT8 || !_rep->_isArray)      if (_rep->_type != CIMTYPE_SINT8 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._sint8Array;     x = *_rep->_u._sint8Array;
Line 1273 
Line 1275 
  
 void CIMValue::get(Array<Uint16>& x) const void CIMValue::get(Array<Uint16>& x) const
 { {
     if (_rep->_type != CIMType::UINT16 || !_rep->_isArray)      if (_rep->_type != CIMTYPE_UINT16 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._uint16Array;     x = *_rep->_u._uint16Array;
Line 1281 
Line 1283 
  
 void CIMValue::get(Array<Sint16>& x) const void CIMValue::get(Array<Sint16>& x) const
 { {
     if (_rep->_type != CIMType::SINT16 || !_rep->_isArray)      if (_rep->_type != CIMTYPE_SINT16 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._sint16Array;     x = *_rep->_u._sint16Array;
Line 1289 
Line 1291 
  
 void CIMValue::get(Array<Uint32>& x) const void CIMValue::get(Array<Uint32>& x) const
 { {
     if (_rep->_type != CIMType::UINT32 || !_rep->_isArray)      if (_rep->_type != CIMTYPE_UINT32 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._uint32Array;     x = *_rep->_u._uint32Array;
Line 1297 
Line 1299 
  
 void CIMValue::get(Array<Sint32>& x) const void CIMValue::get(Array<Sint32>& x) const
 { {
     if (_rep->_type != CIMType::SINT32 || !_rep->_isArray)      if (_rep->_type != CIMTYPE_SINT32 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._sint32Array;     x = *_rep->_u._sint32Array;
Line 1305 
Line 1307 
  
 void CIMValue::get(Array<Uint64>& x) const void CIMValue::get(Array<Uint64>& x) const
 { {
     if (_rep->_type != CIMType::UINT64 || !_rep->_isArray)      if (_rep->_type != CIMTYPE_UINT64 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._uint64Array;     x = *_rep->_u._uint64Array;
Line 1313 
Line 1315 
  
 void CIMValue::get(Array<Sint64>& x) const void CIMValue::get(Array<Sint64>& x) const
 { {
     if (_rep->_type != CIMType::SINT64 || !_rep->_isArray)      if (_rep->_type != CIMTYPE_SINT64 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._sint64Array;     x = *_rep->_u._sint64Array;
Line 1321 
Line 1323 
  
 void CIMValue::get(Array<Real32>& x) const void CIMValue::get(Array<Real32>& x) const
 { {
     if (_rep->_type != CIMType::REAL32 || !_rep->_isArray)      if (_rep->_type != CIMTYPE_REAL32 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._real32Array;     x = *_rep->_u._real32Array;
Line 1329 
Line 1331 
  
 void CIMValue::get(Array<Real64>& x) const void CIMValue::get(Array<Real64>& x) const
 { {
     if (_rep->_type != CIMType::REAL64 || !_rep->_isArray)      if (_rep->_type != CIMTYPE_REAL64 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._real64Array;     x = *_rep->_u._real64Array;
Line 1337 
Line 1339 
  
 void CIMValue::get(Array<Char16>& x) const void CIMValue::get(Array<Char16>& x) const
 { {
     if (_rep->_type != CIMType::CHAR16 || !_rep->_isArray)      if (_rep->_type != CIMTYPE_CHAR16 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._char16Array;     x = *_rep->_u._char16Array;
Line 1345 
Line 1347 
  
 void CIMValue::get(Array<String>& x) const void CIMValue::get(Array<String>& x) const
 { {
     if (_rep->_type != CIMType::STRING || !_rep->_isArray)      if (_rep->_type != CIMTYPE_STRING || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._stringArray;     x = *_rep->_u._stringArray;
Line 1353 
Line 1355 
  
 void CIMValue::get(Array<CIMDateTime>& x) const void CIMValue::get(Array<CIMDateTime>& x) const
 { {
 #ifdef CIMValueisNullexception  // ATTN-RK-20020815: Use UninitializedObject exception here if CIMValue is null?
     if (_rep->_isNull)  
         throw CIMValueIsNull();  
 #endif  
  
     if (_rep->_type != CIMType::DATETIME || !_rep->_isArray)      if (_rep->_type != CIMTYPE_DATETIME || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._dateTimeArray;     x = *_rep->_u._dateTimeArray;
Line 1366 
Line 1365 
  
 void CIMValue::get(Array<CIMObjectPath>& x) const void CIMValue::get(Array<CIMObjectPath>& x) const
 { {
     if (_rep->_type != CIMType::REFERENCE || !_rep->_isArray)      if (_rep->_type != CIMTYPE_REFERENCE || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x = *_rep->_u._referenceArray;     x = *_rep->_u._referenceArray;
Line 1384 
Line 1383 
     {     {
         switch (_rep->_type)         switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 return (*_rep->_u._booleanArray) ==                 return (*_rep->_u._booleanArray) ==
                     (*x._rep->_u._booleanArray);                     (*x._rep->_u._booleanArray);
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 return (*_rep->_u._uint8Array) ==                 return (*_rep->_u._uint8Array) ==
                     (*x._rep->_u._uint8Array);                     (*x._rep->_u._uint8Array);
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 return (*_rep->_u._sint8Array) ==                 return (*_rep->_u._sint8Array) ==
                     (*x._rep->_u._sint8Array);                     (*x._rep->_u._sint8Array);
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 return (*_rep->_u._uint16Array) ==                 return (*_rep->_u._uint16Array) ==
                     (*x._rep->_u._uint16Array);                     (*x._rep->_u._uint16Array);
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 return (*_rep->_u._sint16Array) ==                 return (*_rep->_u._sint16Array) ==
                     (*x._rep->_u._sint16Array);                     (*x._rep->_u._sint16Array);
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 return (*_rep->_u._uint32Array) ==                 return (*_rep->_u._uint32Array) ==
                     (*x._rep->_u._uint32Array);                     (*x._rep->_u._uint32Array);
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 return (*_rep->_u._sint32Array) ==                 return (*_rep->_u._sint32Array) ==
                     (*x._rep->_u._sint32Array);                     (*x._rep->_u._sint32Array);
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 return (*_rep->_u._uint64Array) ==                 return (*_rep->_u._uint64Array) ==
                     (*x._rep->_u._uint64Array);                     (*x._rep->_u._uint64Array);
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 return (*_rep->_u._sint64Array) ==                 return (*_rep->_u._sint64Array) ==
                     (*x._rep->_u._sint64Array);                     (*x._rep->_u._sint64Array);
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 return (*_rep->_u._real32Array) ==                 return (*_rep->_u._real32Array) ==
                     (*x._rep->_u._real32Array);                     (*x._rep->_u._real32Array);
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 return (*_rep->_u._real64Array) ==                 return (*_rep->_u._real64Array) ==
                     (*x._rep->_u._real64Array);                     (*x._rep->_u._real64Array);
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 return (*_rep->_u._char16Array) ==                 return (*_rep->_u._char16Array) ==
                     (*x._rep->_u._char16Array);                     (*x._rep->_u._char16Array);
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 return (*_rep->_u._stringArray) ==                 return (*_rep->_u._stringArray) ==
                     (*x._rep->_u._stringArray);                     (*x._rep->_u._stringArray);
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 return (*_rep->_u._dateTimeArray) ==                 return (*_rep->_u._dateTimeArray) ==
                     (*x._rep->_u._dateTimeArray);                     (*x._rep->_u._dateTimeArray);
  
             case CIMType::REFERENCE:              case CIMTYPE_REFERENCE:
                 return (*_rep->_u._referenceArray) ==                 return (*_rep->_u._referenceArray) ==
                     (*x._rep->_u._referenceArray);                     (*x._rep->_u._referenceArray);
             default:             default:
Line 1451 
Line 1450 
     {     {
         switch (_rep->_type)         switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 return _rep->_u._booleanValue == x._rep->_u._booleanValue;                 return _rep->_u._booleanValue == x._rep->_u._booleanValue;
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 return _rep->_u._uint8Value == x._rep->_u._uint8Value;                 return _rep->_u._uint8Value == x._rep->_u._uint8Value;
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 return _rep->_u._sint8Value == x._rep->_u._sint8Value;                 return _rep->_u._sint8Value == x._rep->_u._sint8Value;
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 return _rep->_u._uint16Value == x._rep->_u._uint16Value;                 return _rep->_u._uint16Value == x._rep->_u._uint16Value;
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 return _rep->_u._sint16Value == x._rep->_u._sint16Value;                 return _rep->_u._sint16Value == x._rep->_u._sint16Value;
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 return _rep->_u._uint32Value == x._rep->_u._uint32Value;                 return _rep->_u._uint32Value == x._rep->_u._uint32Value;
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 return _rep->_u._sint32Value == x._rep->_u._sint32Value;                 return _rep->_u._sint32Value == x._rep->_u._sint32Value;
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 return _rep->_u._uint64Value == x._rep->_u._uint64Value;                 return _rep->_u._uint64Value == x._rep->_u._uint64Value;
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 return _rep->_u._sint64Value == x._rep->_u._sint64Value;                 return _rep->_u._sint64Value == x._rep->_u._sint64Value;
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 return _rep->_u._real32Value == x._rep->_u._real32Value;                 return _rep->_u._real32Value == x._rep->_u._real32Value;
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 return _rep->_u._real64Value == x._rep->_u._real64Value;                 return _rep->_u._real64Value == x._rep->_u._real64Value;
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 return _rep->_u._char16Value == x._rep->_u._char16Value;                 return _rep->_u._char16Value == x._rep->_u._char16Value;
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 return String::equal(*_rep->_u._stringValue,                 return String::equal(*_rep->_u._stringValue,
                                      *x._rep->_u._stringValue);                                      *x._rep->_u._stringValue);
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 return *_rep->_u._dateTimeValue == *x._rep->_u._dateTimeValue;                 return *_rep->_u._dateTimeValue == *x._rep->_u._dateTimeValue;
  
             case CIMType::REFERENCE:              case CIMTYPE_REFERENCE:
                 return *_rep->_u._referenceValue ==                 return *_rep->_u._referenceValue ==
                     *x._rep->_u._referenceValue;                     *x._rep->_u._referenceValue;
  
Line 1520 
Line 1519 
     {     {
         switch (_rep->_type)         switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
             {             {
                 Uint32 size = _rep->_u._booleanArray->size();                 Uint32 size = _rep->_u._booleanArray->size();
                 for (Uint32 i = 0; i < size; i++)                 for (Uint32 i = 0; i < size; i++)
Line 1531 
Line 1530 
                 break;                 break;
             }             }
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 _toString(out, _rep->_u._uint8Array->getData(),                 _toString(out, _rep->_u._uint8Array->getData(),
                                _rep->_u._uint8Array->size());                                _rep->_u._uint8Array->size());
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 _toString(out, _rep->_u._sint8Array->getData(),                 _toString(out, _rep->_u._sint8Array->getData(),
                                _rep->_u._sint8Array->size());                                _rep->_u._sint8Array->size());
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 _toString(out, _rep->_u._uint16Array->getData(),                 _toString(out, _rep->_u._uint16Array->getData(),
                                _rep->_u._uint16Array->size());                                _rep->_u._uint16Array->size());
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 _toString(out, _rep->_u._sint16Array->getData(),                 _toString(out, _rep->_u._sint16Array->getData(),
                                _rep->_u._sint16Array->size());                                _rep->_u._sint16Array->size());
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 _toString(out, _rep->_u._uint32Array->getData(),                 _toString(out, _rep->_u._uint32Array->getData(),
                                _rep->_u._uint32Array->size());                                _rep->_u._uint32Array->size());
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 _toString(out, _rep->_u._sint32Array->getData(),                 _toString(out, _rep->_u._sint32Array->getData(),
                                _rep->_u._sint32Array->size());                                _rep->_u._sint32Array->size());
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 _toString(out, _rep->_u._uint64Array->getData(),                 _toString(out, _rep->_u._uint64Array->getData(),
                                _rep->_u._uint64Array->size());                                _rep->_u._uint64Array->size());
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 _toString(out, _rep->_u._sint64Array->getData(),                 _toString(out, _rep->_u._sint64Array->getData(),
                                _rep->_u._sint64Array->size());                                _rep->_u._sint64Array->size());
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 _toString(out, _rep->_u._real32Array->getData(),                 _toString(out, _rep->_u._real32Array->getData(),
                                _rep->_u._real32Array->size());                                _rep->_u._real32Array->size());
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 _toString(out, _rep->_u._real64Array->getData(),                 _toString(out, _rep->_u._real64Array->getData(),
                                _rep->_u._real64Array->size());                                _rep->_u._real64Array->size());
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 _toString(out, _rep->_u._char16Array->getData(),                 _toString(out, _rep->_u._char16Array->getData(),
                                _rep->_u._char16Array->size());                                _rep->_u._char16Array->size());
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 _toString(out, _rep->_u._stringArray->getData(),                 _toString(out, _rep->_u._stringArray->getData(),
                                _rep->_u._stringArray->size());                                _rep->_u._stringArray->size());
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 _toString(out, _rep->_u._dateTimeArray->getData(),                 _toString(out, _rep->_u._dateTimeArray->getData(),
                                _rep->_u._dateTimeArray->size());                                _rep->_u._dateTimeArray->size());
                 break;                 break;
  
             case CIMType::REFERENCE:              case CIMTYPE_REFERENCE:
                 _toString(out, _rep->_u._referenceArray->getData(),                 _toString(out, _rep->_u._referenceArray->getData(),
                                _rep->_u._referenceArray->size());                                _rep->_u._referenceArray->size());
                 break;                 break;
Line 1609 
Line 1608 
     {     {
         switch (_rep->_type)         switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 _toString(out, Boolean(_rep->_u._booleanValue != 0));                 _toString(out, Boolean(_rep->_u._booleanValue != 0));
                 break;                 break;
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 _toString(out, _rep->_u._uint8Value);                 _toString(out, _rep->_u._uint8Value);
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 _toString(out, _rep->_u._sint8Value);                 _toString(out, _rep->_u._sint8Value);
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 _toString(out, _rep->_u._uint16Value);                 _toString(out, _rep->_u._uint16Value);
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 _toString(out, _rep->_u._sint16Value);                 _toString(out, _rep->_u._sint16Value);
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 _toString(out, _rep->_u._uint32Value);                 _toString(out, _rep->_u._uint32Value);
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 _toString(out, _rep->_u._sint32Value);                 _toString(out, _rep->_u._sint32Value);
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 _toString(out, _rep->_u._uint64Value);                 _toString(out, _rep->_u._uint64Value);
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 _toString(out, _rep->_u._sint64Value);                 _toString(out, _rep->_u._sint64Value);
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 _toString(out, _rep->_u._real32Value);                 _toString(out, _rep->_u._real32Value);
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 _toString(out, _rep->_u._real64Value);                 _toString(out, _rep->_u._real64Value);
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 _toString(out, Char16(_rep->_u._char16Value));                 _toString(out, Char16(_rep->_u._char16Value));
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 _toString(out, *_rep->_u._stringValue);                 _toString(out, *_rep->_u._stringValue);
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 _toString(out, *_rep->_u._dateTimeValue);                 _toString(out, *_rep->_u._dateTimeValue);
                 break;                 break;
  
             case CIMType::REFERENCE:              case CIMTYPE_REFERENCE:
                 _toString(out, *_rep->_u._referenceValue);                 _toString(out, *_rep->_u._referenceValue);
                 break;                 break;
  

Legend:
Removed from v.1.35  
changed lines
  Added in v.1.37
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2