(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.31 and 1.32

version 1.31, 2002/05/15 23:14:21 version 1.32, 2002/05/17 02:35:51
Line 42 
Line 42 
 # include "ArrayImpl.h" # include "ArrayImpl.h"
 #undef PEGASUS_ARRAY_T #undef PEGASUS_ARRAY_T
  
 template<class T>  
 inline void _Inc(ArrayRep<T>* rep)  
 {  
     ArrayRep<T>::inc(rep);  
 }  
   
 template<class T>  
 inline void _Dec(ArrayRep<T>* rep)  
 {  
     ArrayRep<T>::dec(rep);  
 }  
   
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
 // _toString routines: // _toString routines:
Line 379 
Line 367 
         switch (_rep->_type)         switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:             case CIMType::BOOLEAN:
                 _Inc(_rep->_u._booleanArray = x._rep->_u._booleanArray);                  _rep->_u._booleanArray =
                       new Array<Boolean>(*(x._rep->_u._booleanArray));
                 break;                 break;
  
             case CIMType::UINT8:             case CIMType::UINT8:
                 _Inc(_rep->_u._uint8Array = x._rep->_u._uint8Array);                  _rep->_u._uint8Array =
                       new Array<Uint8>(*(x._rep->_u._uint8Array));
                 break;                 break;
  
             case CIMType::SINT8:             case CIMType::SINT8:
                 _Inc(_rep->_u._sint8Array = x._rep->_u._sint8Array);                  _rep->_u._sint8Array =
                       new Array<Sint8>(*(x._rep->_u._sint8Array));
                 break;                 break;
  
             case CIMType::UINT16:             case CIMType::UINT16:
                 _Inc(_rep->_u._uint16Array = x._rep->_u._uint16Array);                  _rep->_u._uint16Array =
                       new Array<Uint16>(*(x._rep->_u._uint16Array));
                 break;                 break;
  
             case CIMType::SINT16:             case CIMType::SINT16:
                 _Inc(_rep->_u._sint16Array = x._rep->_u._sint16Array);                  _rep->_u._sint16Array =
                       new Array<Sint16>(*(x._rep->_u._sint16Array));
                 break;                 break;
  
             case CIMType::UINT32:             case CIMType::UINT32:
                 _Inc(_rep->_u._uint32Array = x._rep->_u._uint32Array);                  _rep->_u._uint32Array =
                       new Array<Uint32>(*(x._rep->_u._uint32Array));
                 break;                 break;
  
             case CIMType::SINT32:             case CIMType::SINT32:
                 _Inc(_rep->_u._sint32Array = x._rep->_u._sint32Array);                  _rep->_u._sint32Array =
                       new Array<Sint32>(*(x._rep->_u._sint32Array));
                 break;                 break;
  
             case CIMType::UINT64:             case CIMType::UINT64:
                 _Inc(_rep->_u._uint64Array = x._rep->_u._uint64Array);                  _rep->_u._uint64Array =
                       new Array<Uint64>(*(x._rep->_u._uint64Array));
                 break;                 break;
  
             case CIMType::SINT64:             case CIMType::SINT64:
                 _Inc(_rep->_u._sint64Array = x._rep->_u._sint64Array);                  _rep->_u._sint64Array =
                       new Array<Sint64>(*(x._rep->_u._sint64Array));
                 break;                 break;
  
             case CIMType::REAL32:             case CIMType::REAL32:
                 _Inc(_rep->_u._real32Array = x._rep->_u._real32Array);                  _rep->_u._real32Array =
                       new Array<Real32>(*(x._rep->_u._real32Array));
                 break;                 break;
  
             case CIMType::REAL64:             case CIMType::REAL64:
                 _Inc(_rep->_u._real64Array = x._rep->_u._real64Array);                  _rep->_u._real64Array =
                       new Array<Real64>(*(x._rep->_u._real64Array));
                 break;                 break;
  
             case CIMType::CHAR16:             case CIMType::CHAR16:
                 _Inc(_rep->_u._char16Array = x._rep->_u._char16Array);                  _rep->_u._char16Array =
                       new Array<Char16>(*(x._rep->_u._char16Array));
                 break;                 break;
  
             case CIMType::STRING:             case CIMType::STRING:
                 _Inc(_rep->_u._stringArray = x._rep->_u._stringArray);                  _rep->_u._stringArray =
                       new Array<String>(*(x._rep->_u._stringArray));
                 break;                 break;
  
             case CIMType::DATETIME:             case CIMType::DATETIME:
                 _Inc(_rep->_u._dateTimeArray = x._rep->_u._dateTimeArray);                  _rep->_u._dateTimeArray =
                       new Array<CIMDateTime>(*(x._rep->_u._dateTimeArray));
                 break;                 break;
  
             case CIMType::REFERENCE:             case CIMType::REFERENCE:
                 _Inc(_rep->_u._referenceArray = x._rep->_u._referenceArray);                  _rep->_u._referenceArray =
                       new Array<CIMObjectPath>(*(x._rep->_u._referenceArray));
                 break;                 break;
             default:             default:
                 throw CIMValueInvalidType();                 throw CIMValueInvalidType();
Line 527 
Line 530 
         switch (_rep->_type)         switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:             case CIMType::BOOLEAN:
                 _Dec(_rep->_u._booleanArray);                  delete _rep->_u._booleanArray;
                 break;                 break;
  
             case CIMType::UINT8:             case CIMType::UINT8:
                 _Dec(_rep->_u._uint8Array);                  delete _rep->_u._uint8Array;
                 break;                 break;
  
             case CIMType::SINT8:             case CIMType::SINT8:
                 _Dec(_rep->_u._sint8Array);                  delete _rep->_u._sint8Array;
                 break;                 break;
  
             case CIMType::UINT16:             case CIMType::UINT16:
                 _Dec(_rep->_u._uint16Array);                  delete _rep->_u._uint16Array;
                 break;                 break;
  
             case CIMType::SINT16:             case CIMType::SINT16:
                 _Dec(_rep->_u._sint16Array);                  delete _rep->_u._sint16Array;
                 break;                 break;
  
             case CIMType::UINT32:             case CIMType::UINT32:
                 _Dec(_rep->_u._uint32Array);                  delete _rep->_u._uint32Array;
                 break;                 break;
  
             case CIMType::SINT32:             case CIMType::SINT32:
                 _Dec(_rep->_u._sint32Array);                  delete _rep->_u._sint32Array;
                 break;                 break;
  
             case CIMType::UINT64:             case CIMType::UINT64:
                 _Dec(_rep->_u._uint64Array);                  delete _rep->_u._uint64Array;
                 break;                 break;
  
             case CIMType::SINT64:             case CIMType::SINT64:
                 _Dec(_rep->_u._sint64Array);                  delete _rep->_u._sint64Array;
                 break;                 break;
  
             case CIMType::REAL32:             case CIMType::REAL32:
                 _Dec(_rep->_u._real32Array);                  delete _rep->_u._real32Array;
                 break;                 break;
  
             case CIMType::REAL64:             case CIMType::REAL64:
                 _Dec(_rep->_u._real64Array);                  delete _rep->_u._real64Array;
                 break;                 break;
  
             case CIMType::CHAR16:             case CIMType::CHAR16:
                 _Dec(_rep->_u._char16Array);                  delete _rep->_u._char16Array;
                 break;                 break;
  
             case CIMType::STRING:             case CIMType::STRING:
                 _Dec(_rep->_u._stringArray);                  delete _rep->_u._stringArray;
                 break;                 break;
  
             case CIMType::DATETIME:             case CIMType::DATETIME:
                 _Dec(_rep->_u._dateTimeArray);                  delete _rep->_u._dateTimeArray;
                 break;                 break;
  
             case CIMType::REFERENCE:             case CIMType::REFERENCE:
                 _Dec(_rep->_u._referenceArray);                  delete _rep->_u._referenceArray;
                 break;                 break;
  
             //default:             //default:
Line 654 
Line 657 
             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
         default:         default:
Line 1002 
Line 1005 
 void CIMValue::set(const Array<Boolean>& x) void CIMValue::set(const Array<Boolean>& x)
 { {
     clear();     clear();
     _Inc(_rep->_u._booleanArray = x._rep);      _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 1011 
Line 1014 
 void CIMValue::set(const Array<Uint8>& x) void CIMValue::set(const Array<Uint8>& x)
 { {
     clear();     clear();
     _Inc(_rep->_u._uint8Array = x._rep);      _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 1020 
Line 1023 
 void CIMValue::set(const Array<Sint8>& x) void CIMValue::set(const Array<Sint8>& x)
 { {
     clear();     clear();
     _Inc(_rep->_u._sint8Array = x._rep);      _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 1029 
Line 1032 
 void CIMValue::set(const Array<Uint16>& x) void CIMValue::set(const Array<Uint16>& x)
 { {
     clear();     clear();
     _Inc(_rep->_u._uint16Array = x._rep);      _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 1038 
Line 1041 
 void CIMValue::set(const Array<Sint16>& x) void CIMValue::set(const Array<Sint16>& x)
 { {
     clear();     clear();
     _Inc(_rep->_u._sint16Array = x._rep);      _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 1047 
Line 1050 
 void CIMValue::set(const Array<Uint32>& x) void CIMValue::set(const Array<Uint32>& x)
 { {
     clear();     clear();
     _Inc(_rep->_u._uint32Array = x._rep);      _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 1056 
Line 1059 
 void CIMValue::set(const Array<Sint32>& x) void CIMValue::set(const Array<Sint32>& x)
 { {
     clear();     clear();
     _Inc(_rep->_u._sint32Array = x._rep);      _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 1065 
Line 1068 
 void CIMValue::set(const Array<Uint64>& x) void CIMValue::set(const Array<Uint64>& x)
 { {
     clear();     clear();
     _Inc(_rep->_u._uint64Array = x._rep);      _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 1074 
Line 1077 
 void CIMValue::set(const Array<Sint64>& x) void CIMValue::set(const Array<Sint64>& x)
 { {
     clear();     clear();
     _Inc(_rep->_u._sint64Array = x._rep);      _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 1083 
Line 1086 
 void CIMValue::set(const Array<Real32>& x) void CIMValue::set(const Array<Real32>& x)
 { {
     clear();     clear();
     _Inc(_rep->_u._real32Array = x._rep);      _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 1092 
Line 1095 
 void CIMValue::set(const Array<Real64>& x) void CIMValue::set(const Array<Real64>& x)
 { {
     clear();     clear();
     _Inc(_rep->_u._real64Array = x._rep);      _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 1101 
Line 1104 
 void CIMValue::set(const Array<Char16>& x) void CIMValue::set(const Array<Char16>& x)
 { {
     clear();     clear();
     _Inc(_rep->_u._char16Array = x._rep);      _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 1110 
Line 1113 
 void CIMValue::set(const Array<String>& x) void CIMValue::set(const Array<String>& x)
 { {
     clear();     clear();
     _Inc(_rep->_u._stringArray = x._rep);      _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 1119 
Line 1122 
 void CIMValue::set(const Array<CIMDateTime>& x) void CIMValue::set(const Array<CIMDateTime>& x)
 { {
     clear();     clear();
     _Inc(_rep->_u._dateTimeArray = x._rep);      _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 1128 
Line 1131 
 void CIMValue::set(const Array<CIMObjectPath>& x) void CIMValue::set(const Array<CIMObjectPath>& x)
 { {
     clear();     clear();
     _Inc(_rep->_u._referenceArray = x._rep);      _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;
Line 1259 
Line 1262 
     if (_rep->_type != CIMType::BOOLEAN || !_rep->_isArray)     if (_rep->_type != CIMType::BOOLEAN || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x.set(_rep->_u._booleanArray);      x = *_rep->_u._booleanArray;
 } }
  
 void CIMValue::get(Array<Uint8>& x) const void CIMValue::get(Array<Uint8>& x) const
Line 1267 
Line 1270 
     if (_rep->_type != CIMType::UINT8 || !_rep->_isArray)     if (_rep->_type != CIMType::UINT8 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x.set(_rep->_u._uint8Array);      x = *_rep->_u._uint8Array;
 } }
  
 void CIMValue::get(Array<Sint8>& x) const void CIMValue::get(Array<Sint8>& x) const
Line 1275 
Line 1278 
     if (_rep->_type != CIMType::SINT8 || !_rep->_isArray)     if (_rep->_type != CIMType::SINT8 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x.set(_rep->_u._sint8Array);      x = *_rep->_u._sint8Array;
 } }
  
 void CIMValue::get(Array<Uint16>& x) const void CIMValue::get(Array<Uint16>& x) const
Line 1283 
Line 1286 
     if (_rep->_type != CIMType::UINT16 || !_rep->_isArray)     if (_rep->_type != CIMType::UINT16 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x.set(_rep->_u._uint16Array);      x = *_rep->_u._uint16Array;
 } }
  
 void CIMValue::get(Array<Sint16>& x) const void CIMValue::get(Array<Sint16>& x) const
Line 1291 
Line 1294 
     if (_rep->_type != CIMType::SINT16 || !_rep->_isArray)     if (_rep->_type != CIMType::SINT16 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x.set(_rep->_u._sint16Array);      x = *_rep->_u._sint16Array;
 } }
  
 void CIMValue::get(Array<Uint32>& x) const void CIMValue::get(Array<Uint32>& x) const
Line 1299 
Line 1302 
     if (_rep->_type != CIMType::UINT32 || !_rep->_isArray)     if (_rep->_type != CIMType::UINT32 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x.set(_rep->_u._uint32Array);      x = *_rep->_u._uint32Array;
 } }
  
 void CIMValue::get(Array<Sint32>& x) const void CIMValue::get(Array<Sint32>& x) const
Line 1307 
Line 1310 
     if (_rep->_type != CIMType::SINT32 || !_rep->_isArray)     if (_rep->_type != CIMType::SINT32 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x.set(_rep->_u._sint32Array);      x = *_rep->_u._sint32Array;
 } }
  
 void CIMValue::get(Array<Uint64>& x) const void CIMValue::get(Array<Uint64>& x) const
Line 1315 
Line 1318 
     if (_rep->_type != CIMType::UINT64 || !_rep->_isArray)     if (_rep->_type != CIMType::UINT64 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x.set(_rep->_u._uint64Array);      x = *_rep->_u._uint64Array;
 } }
  
 void CIMValue::get(Array<Sint64>& x) const void CIMValue::get(Array<Sint64>& x) const
Line 1323 
Line 1326 
     if (_rep->_type != CIMType::SINT64 || !_rep->_isArray)     if (_rep->_type != CIMType::SINT64 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x.set(_rep->_u._sint64Array);      x = *_rep->_u._sint64Array;
 } }
  
 void CIMValue::get(Array<Real32>& x) const void CIMValue::get(Array<Real32>& x) const
Line 1331 
Line 1334 
     if (_rep->_type != CIMType::REAL32 || !_rep->_isArray)     if (_rep->_type != CIMType::REAL32 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x.set(_rep->_u._real32Array);      x = *_rep->_u._real32Array;
 } }
  
 void CIMValue::get(Array<Real64>& x) const void CIMValue::get(Array<Real64>& x) const
Line 1339 
Line 1342 
     if (_rep->_type != CIMType::REAL64 || !_rep->_isArray)     if (_rep->_type != CIMType::REAL64 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x.set(_rep->_u._real64Array);      x = *_rep->_u._real64Array;
 } }
  
 void CIMValue::get(Array<Char16>& x) const void CIMValue::get(Array<Char16>& x) const
Line 1347 
Line 1350 
     if (_rep->_type != CIMType::CHAR16 || !_rep->_isArray)     if (_rep->_type != CIMType::CHAR16 || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x.set(_rep->_u._char16Array);      x = *_rep->_u._char16Array;
 } }
  
 void CIMValue::get(Array<String>& x) const void CIMValue::get(Array<String>& x) const
Line 1355 
Line 1358 
     if (_rep->_type != CIMType::STRING || !_rep->_isArray)     if (_rep->_type != CIMType::STRING || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x.set(_rep->_u._stringArray);      x = *_rep->_u._stringArray;
 } }
  
 void CIMValue::get(Array<CIMDateTime>& x) const void CIMValue::get(Array<CIMDateTime>& x) const
Line 1368 
Line 1371 
     if (_rep->_type != CIMType::DATETIME || !_rep->_isArray)     if (_rep->_type != CIMType::DATETIME || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x.set(_rep->_u._dateTimeArray);      x = *_rep->_u._dateTimeArray;
 } }
  
 void CIMValue::get(Array<CIMObjectPath>& x) const void CIMValue::get(Array<CIMObjectPath>& x) const
Line 1376 
Line 1379 
     if (_rep->_type != CIMType::REFERENCE || !_rep->_isArray)     if (_rep->_type != CIMType::REFERENCE || !_rep->_isArray)
         throw TypeMismatch();         throw TypeMismatch();
  
     x.set(_rep->_u._referenceArray);      x = *_rep->_u._referenceArray;
 } }
  
 CIMValue CIMValue::clone() const CIMValue CIMValue::clone() const
Line 1399 
Line 1402 
         {         {
             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++)
                 {                 {
                     _toString(out, Boolean(_rep->_u._booleanArray->data()[i]));                      _toString(out, Boolean(_rep->_u._booleanArray->getData()[i]));
                     out << " ";                     out << " ";
                 }                 }
                 break;                 break;
             }             }
  
             case CIMType::UINT8:             case CIMType::UINT8:
                 _toString(out, _rep->_u._uint8Array->data(),                  _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->data(),                  _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->data(),                  _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->data(),                  _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->data(),                  _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->data(),                  _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->data(),                  _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->data(),                  _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->data(),                  _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->data(),                  _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->data(),                  _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->data(),                  _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->data(),                  _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->data(),                  _toString(out, _rep->_u._referenceArray->getData(),
                                _rep->_u._referenceArray->size);                                 _rep->_u._referenceArray->size());
                 break;                 break;
  
             default:             default:
Line 1569 
Line 1572 
         switch (x._rep->_type)         switch (x._rep->_type)
         {         {
             case CIMType::BOOLEAN:             case CIMType::BOOLEAN:
                 return Array<Boolean>(x._rep->_u._booleanArray) ==                  return (*x._rep->_u._booleanArray) ==
                     Array<Boolean>(y._rep->_u._booleanArray);                      (*y._rep->_u._booleanArray);
  
             case CIMType::UINT8:             case CIMType::UINT8:
                 return Array<Uint8>(x._rep->_u._uint8Array) ==                  return (*x._rep->_u._uint8Array) ==
                     Array<Uint8>(y._rep->_u._uint8Array);                      (*y._rep->_u._uint8Array);
  
             case CIMType::SINT8:             case CIMType::SINT8:
                 return Array<Sint8>(x._rep->_u._sint8Array) ==                  return (*x._rep->_u._sint8Array) ==
                     Array<Sint8>(y._rep->_u._sint8Array);                      (*y._rep->_u._sint8Array);
  
             case CIMType::UINT16:             case CIMType::UINT16:
                 return Array<Uint16>(x._rep->_u._uint16Array) ==                  return (*x._rep->_u._uint16Array) ==
                     Array<Uint16>(y._rep->_u._uint16Array);                      (*y._rep->_u._uint16Array);
  
             case CIMType::SINT16:             case CIMType::SINT16:
                 return Array<Sint16>(x._rep->_u._sint16Array) ==                  return (*x._rep->_u._sint16Array) ==
                     Array<Sint16>(y._rep->_u._sint16Array);                      (*y._rep->_u._sint16Array);
  
             case CIMType::UINT32:             case CIMType::UINT32:
                 return Array<Uint32>(x._rep->_u._uint32Array) ==                  return (*x._rep->_u._uint32Array) ==
                     Array<Uint32>(y._rep->_u._uint32Array);                      (*y._rep->_u._uint32Array);
  
             case CIMType::SINT32:             case CIMType::SINT32:
                 return Array<Sint32>(x._rep->_u._sint32Array) ==                  return (*x._rep->_u._sint32Array) ==
                     Array<Sint32>(y._rep->_u._sint32Array);                      (*y._rep->_u._sint32Array);
  
             case CIMType::UINT64:             case CIMType::UINT64:
                 return Array<Uint64>(x._rep->_u._uint64Array) ==                  return (*x._rep->_u._uint64Array) ==
                     Array<Uint64>(y._rep->_u._uint64Array);                      (*y._rep->_u._uint64Array);
  
             case CIMType::SINT64:             case CIMType::SINT64:
                 return Array<Sint64>(x._rep->_u._sint64Array) ==                  return (*x._rep->_u._sint64Array) ==
                     Array<Sint64>(y._rep->_u._sint64Array);                      (*y._rep->_u._sint64Array);
  
             case CIMType::REAL32:             case CIMType::REAL32:
                 return Array<Real32>(x._rep->_u._real32Array) ==                  return (*x._rep->_u._real32Array) ==
                     Array<Real32>(y._rep->_u._real32Array);                      (*y._rep->_u._real32Array);
  
             case CIMType::REAL64:             case CIMType::REAL64:
                 return Array<Real64>(x._rep->_u._real64Array) ==                  return (*x._rep->_u._real64Array) ==
                     Array<Real64>(y._rep->_u._real64Array);                      (*y._rep->_u._real64Array);
  
             case CIMType::CHAR16:             case CIMType::CHAR16:
                 return Array<Char16>(x._rep->_u._char16Array) ==                  return (*x._rep->_u._char16Array) ==
                     Array<Char16>(y._rep->_u._char16Array);                      (*y._rep->_u._char16Array);
  
             case CIMType::STRING:             case CIMType::STRING:
                 return Array<String>(x._rep->_u._stringArray) ==                  return (*x._rep->_u._stringArray) ==
                     Array<String>(y._rep->_u._stringArray);                      (*y._rep->_u._stringArray);
  
             case CIMType::DATETIME:             case CIMType::DATETIME:
                 return Array<CIMDateTime>(x._rep->_u._dateTimeArray) ==                  return (*x._rep->_u._dateTimeArray) ==
                     Array<CIMDateTime>(y._rep->_u._dateTimeArray);                      (*y._rep->_u._dateTimeArray);
  
             case CIMType::REFERENCE:             case CIMType::REFERENCE:
                 return Array<CIMObjectPath>(x._rep->_u._referenceArray) ==                  return (*x._rep->_u._referenceArray) ==
                     Array<CIMObjectPath>(y._rep->_u._referenceArray);                      (*y._rep->_u._referenceArray);
             default:             default:
                 throw CIMValueInvalidType();                 throw CIMValueInvalidType();
         }         }

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