(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.27 and 1.37

version 1.27, 2002/05/11 21:36:29 version 1.37, 2002/08/16 01:28:06
Line 1 
Line 1 
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
   // The Open Group, Tivoli Systems
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 24 
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)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <cstring> #include <cstring>
 #include <cstdio> #include <cstdio>
 #include <cassert>  
 #include <cctype> #include <cctype>
 #include "CIMValue.h" #include "CIMValue.h"
 #include "Union.h" #include "Union.h"
Line 42 
Line 44 
 # 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);  
 }  
   
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
 // Local helper functions:  // _toString routines:
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 // Too complicated.  Commented out in favor of sprintf("%lld"/"%llu").  
 #if 0  
 //------------------------------------------------------------------------------  
 //  
 // _SignedIntToStr()  
 //  
 //------------------------------------------------------------------------------  
   
 static void _SignedIntToStr(Sint64 x, char* result)  
 {  
     if (!result)  
         return;  
   
     if (x == 0)  
     {  
         result[0] = '0';  
         result[1] = '\0';  
         return;  
     }  
   
     char buffer[32];  
     Uint32 len = 0;  
     Boolean negative = false;  
   
     while (x)  
     {  
         Sint32 r = x % 10;  
         x = x / 10;  
   
         if (r < 0)  
         {  
             r = -r;  
             negative = true;  
         }  
   
         buffer[len++] = r + '0';  
     }  
   
     buffer[len] = '\0';  
   
     // If buffer was negative, prepend sign:  
   
     char* q = result;  
   
     if (negative)  
         *q++ = '-';  
   
     // Reverse the buffer:  
   
     char* p = &buffer[len];  
   
     while (len--)  
         *q++ = *--p;  
   
     *q++ = '\0';  
 }  
   
 //------------------------------------------------------------------------------  
 //  
 // _UnsignedIntToStr()  
 //  
 //------------------------------------------------------------------------------  
   
 static void _UnsignedIntToStr(Uint64 x, char* result)  
 {  
     if (!result)  
         return;  
   
     if (x == 0)  
     {  
         result[0] = '0';  
         result[1] = '\0';  
         return;  
     }  
   
     char buffer[32];  
     Uint32 len = 0;  
   
     while (x)  
     {  
         Uint32 r = x % 10;  
         x = x / 10;  
   
         buffer[len++] = r + '0';  
     }  
   
     buffer[len] = '\0';  
   
     // Reverse the buffer onto output:  
   
     char* q = result;  
   
     char* p = &buffer[len];  
   
     while (len--)  
         *q++ = *--p;  
   
     *q++ = '\0';  
 }  
 #endif  
   
 //------------------------------------------------------------------------------  
 //  
 // _toString, _toXml(), and _toMof routines:  
 //  
 //------------------------------------------------------------------------------  
   
 inline void _toString(Array<Sint8>& out, Boolean x) inline void _toString(Array<Sint8>& out, Boolean x)
 { {
     out << (x ? "TRUE" : "FALSE");      XmlWriter::append(out, x);
 } }
  
 inline void _toXml(Array<Sint8>& out, Boolean x) { _toString(out, x); }  inline void _toString(Array<Sint8>& out, Uint8 x) { XmlWriter::append(out, Uint32(x)); }
 inline void _toMof(Array<Sint8>& out, Boolean x) { _toString(out, x); }  inline void _toString(Array<Sint8>& out, Sint8 x) { XmlWriter::append(out, Sint32(x)); }
   inline void _toString(Array<Sint8>& out, Uint16 x) { XmlWriter::append(out, Uint32(x)); }
 inline void _integerToString(Array<Sint8>& out, Sint32 x)  inline void _toString(Array<Sint8>& out, Sint16 x) { XmlWriter::append(out, Sint32(x)); }
 {  inline void _toString(Array<Sint8>& out, Uint32 x) { XmlWriter::append(out, x); }
     char buffer[32];  inline void _toString(Array<Sint8>& out, Sint32 x) { XmlWriter::append(out, x); }
     sprintf(buffer, "%d", x);  inline void _toString(Array<Sint8>& out, Uint64 x) { XmlWriter::append(out, x); }
     out << (char*)buffer;  inline void _toString(Array<Sint8>& out, Sint64 x) { XmlWriter::append(out, x); }
 }  inline void _toString(Array<Sint8>& out, Real32 x) { XmlWriter::append(out, Real64(x)); }
   inline void _toString(Array<Sint8>& out, Real64 x) { XmlWriter::append(out, x); }
 inline void _unsignedIntegerToString(Array<Sint8>& out, Uint32 x)  
 {  
     char buffer[32];  
     sprintf(buffer, "%u", x);  
     out << (char*)buffer;  
 }  
   
 inline void _toString(Array<Sint8>& out, Uint8 x) { _unsignedIntegerToString(out, x); }  
 inline void _toXml(Array<Sint8>& out, Uint8 x) { _toString(out, x); }  
 inline void _toMof(Array<Sint8>& out, Uint8 x) { _toString(out, x); }  
   
 inline void _toString(Array<Sint8>& out, Sint8 x) { _integerToString(out, x); }  
 inline void _toXml(Array<Sint8>& out, Sint8 x) { _toString(out, x); }  
 inline void _toMof(Array<Sint8>& out, Sint8 x) { _toString(out, x); }  
   
 inline void _toString(Array<Sint8>& out, Uint16 x) { _unsignedIntegerToString(out, x); }  
 inline void _toXml(Array<Sint8>& out, Uint16 x) { _toString(out, x); }  
 inline void _toMof(Array<Sint8>& out, Uint16 x) { _toString(out, x); }  
   
 inline void _toString(Array<Sint8>& out, Sint16 x) { _integerToString(out, x); }  
 inline void _toXml(Array<Sint8>& out, Sint16 x) { _toString(out, x); }  
 inline void _toMof(Array<Sint8>& out, Sint16 x) { _toString(out, x); }  
   
 inline void _toString(Array<Sint8>& out, Uint32 x) { _unsignedIntegerToString(out, x); }  
 inline void _toXml(Array<Sint8>& out, Uint32 x) { _toString(out, x); }  
 inline void _toMof(Array<Sint8>& out, Uint32 x) { _toString(out, x); }  
   
 inline void _toString(Array<Sint8>& out, Sint32 x) { _integerToString(out, x); }  
 inline void _toXml(Array<Sint8>& out, Sint32 x) { _toString(out, x); }  
 inline void _toMof(Array<Sint8>& out, Sint32 x) { _toString(out, x); }  
   
 inline void _toString(Array<Sint8>& out, Uint64 x)  
 {  
     char buffer[32];  // Should need 21 chars max  
     // I know I shouldn't put platform flags here, but the other was is too hard  
 #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)  
     sprintf(buffer, "%I64u", x);  
 #else  
     sprintf(buffer, "%llu", x);  
 #endif  
     out << buffer;  
 }  
   
 inline void _toXml(Array<Sint8>& out, Uint64 x) { _toString(out, x); }  
 inline void _toMof(Array<Sint8>& out, Uint64 x) { _toString(out, x); }  
   
 inline void _toString(Array<Sint8>& out, Sint64 x)  
 {  
     char buffer[32];  // Should need 21 chars max  
     // I know I shouldn't put platform flags here, but the other was is too hard  
 #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)  
     sprintf(buffer, "%I64d", x);  
 #else  
     sprintf(buffer, "%lld", x);  
 #endif  
     out << buffer;  
 }  
   
 inline void _toXml(Array<Sint8>& out, Sint64 x) { _toString(out, x); }  
 inline void _toMof(Array<Sint8>& out, Sint64 x) { _toString(out, x); }  
   
 void _toString(Array<Sint8>& out, Real64 x)  
 {  
     char buffer[128];  
     // %e gives '[-]m.dddddde+/-xx', which seems compatible with CIM/XML spec  
     sprintf(buffer, "%e", x);  
     out << buffer;  
 }  
   
 inline void _toXml(Array<Sint8>& out, Real64 x) { _toString(out, x); }  
 inline void _toMof(Array<Sint8>& out, Real64 x) { _toString(out, x); }  
   
 inline void _toString(Array<Sint8>& out, Real32 x) { _toString(out, Real64(x)); }  
 inline void _toXml(Array<Sint8>& out, Real32 x) { _toString(out, x); }  
 inline void _toMof(Array<Sint8>& out, Real32 x) { _toString(out, x); }  
  
 inline void _toString(Array<Sint8>& out, Char16 x) inline void _toString(Array<Sint8>& out, Char16 x)
 { {
     // ATTN: How to convert 16-bit characters to printable form?     // ATTN: How to convert 16-bit characters to printable form?
     out.append(Sint8(x));     out.append(Sint8(x));
 } }
 inline void _toXml(Array<Sint8>& out, Char16 x)  
 {  
     XmlWriter::appendSpecial(out, x);  
 }  
 inline void _toMof(Array<Sint8>& out, Char16 x)  
 {  
     XmlWriter::appendSpecial(out, x);  
 }  
  
 inline void _toString(Array<Sint8>& out, const String& x) inline void _toString(Array<Sint8>& out, const String& x)
 { {
     out << x;     out << x;
 } }
  
 inline void _toXml(Array<Sint8>& out, const String& x)  
 {  
     XmlWriter::appendSpecial(out, x);  
 }  
   
 /** _toMof Internal function to convert the string back  
     to MOF format and output it.  
     The conversions are:  
     \b // \x0008: backspace BS  
     \t // \x0009: horizontal tab HT  
     \n // \x000A: linefeed LF  
     \f // \x000C: form feed FF  
     \r // \x000D: carriage return CR  
     \" // \x0022: double quote "  
     \’ // \x0027: single quote '  
     \\ // \x005C: backslash \  
     \x<hex> // where <hex> is one to four hex digits  
     \X<hex> // where <hex> is one to four hex digits  
 */  
 /* ATTN:KS - We need to account for characters greater than x'7f  
 */  
 inline void _toMof(Array<Sint8>& out, const String& x)  
 {  
     out << "\"";  
     const Char16* tmp = x.getData();  
     char c;  
     while ((c = *tmp++))  
     {  
         switch (c)  
         {  
         case '\\':  
                 out.append("\\\\",2);  
                 break;  
   
             case '\b':  
                 out.append("\\b",2);  
                 break;  
   
             case '\t':  
                 out.append("\\t",2);  
                 break;  
   
             case '\n':  
                 out.append("\\n",2);  
                 break;  
   
             case '\f':  
                 out.append("\\f",2);  
                 break;  
   
             case '\r':  
                 out.append("\\r",2);  
                 break;  
   
            /* case '\'':  
                 out.append("\\'", 2);  
                 break;*/  
   
             case '"':  
                 out.append("\\\"", 2);  
                 break;  
   
             default:  
                 out.append(Sint8(c));  
         }  
   
     }  
     out << "\"";  
 }  
   
 inline void _toString(Array<Sint8>& out, const CIMDateTime& x) inline void _toString(Array<Sint8>& out, const CIMDateTime& x)
 { {
     out << x.getString();     out << x.getString();
 } }
  
 inline void _toXml(Array<Sint8>& out, const CIMDateTime& x) { _toString(out, x); }  inline void _toString(Array<Sint8>& out, const CIMObjectPath& x)
 inline void _toMof(Array<Sint8>& out, const CIMDateTime& x) { _toString(out, x); }  
   
 inline void _toString(Array<Sint8>& out, const CIMReference& x)  
 { {
     out << x.toString();     out << x.toString();
 } }
 inline void _toXml(Array<Sint8>& out, const CIMReference& x)  
 {  
     x.toXml(out);  
 }  
 inline void _toMof(Array<Sint8>& out, const CIMReference& x)  
 {  
     x.toMof(out);  
 }  
  
 template<class T> template<class T>
 void _toString(Array<Sint8>& out, const T* p, Uint32 size) void _toString(Array<Sint8>& out, const T* p, Uint32 size)
Line 378 
Line 97 
     }     }
 } }
  
 void _toXml(Array<Sint8>& out, const CIMReference* p, Uint32 size)  
 {  
     out << "<VALUE.REFARRAY>\n";  
     while (size--)  
     {  
         _toXml(out, *p++);  
     }  
     out << "</VALUE.REFARRAY>\n";  
 }  
   
 template<class T>  
 void _toXml(Array<Sint8>& out, const T* p, Uint32 size)  
 {  
     out << "<VALUE.ARRAY>\n";  
   
     while (size--)  
     {  
         out << "<VALUE>";  
   
         _toXml(out, *p++);  
   
         out << "</VALUE>\n";  
     }  
   
     out << "</VALUE.ARRAY>\n";  
 }  
 /** _toMof Array -  
     arrayInitializer  = "{" constantValue*( "," constantValue)"}"  
   
 */  
 template<class T>  
 void _toMof(Array<Sint8>& out, const T* p, Uint32 size)  
 {  
     Boolean isFirstEntry = true;  
     // if there are any entries in the array output them  
     if (size)  
     {  
         out << "{";  
         while (size--)  
         {  
             // Put comma on all but first entry.  
             if (!isFirstEntry)  
             {  
                 out << ", ";  
             }  
             isFirstEntry = false;  
             _toMof(out, *p++);  
         }  
         out << "}";  
   
     }  
 }  
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
Line 451 
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 559 
Line 226 
     set(x);     set(x);
 } }
  
 CIMValue::CIMValue(const char* x)  
 {  
     _rep = new CIMValueRep();  
     set(x);  
 }  
   
 CIMValue::CIMValue(const CIMDateTime& x) CIMValue::CIMValue(const CIMDateTime& x)
 { {
     _rep = new CIMValueRep();     _rep = new CIMValueRep();
     set(x);     set(x);
 } }
  
 CIMValue::CIMValue(const CIMReference& x)  CIMValue::CIMValue(const CIMObjectPath& x)
 { {
     _rep = new CIMValueRep();     _rep = new CIMValueRep();
     set(x);     set(x);
Line 661 
Line 322 
     set(x);     set(x);
 } }
  
 CIMValue::CIMValue(const Array<CIMReference>& x)  CIMValue::CIMValue(const Array<CIMObjectPath>& x)
 { {
     _rep = new CIMValueRep();     _rep = new CIMValueRep();
     set(x);     set(x);
Line 701 
Line 362 
     {     {
         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 768 
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 CIMReference(*(x._rep->_u._referenceValue));                      new CIMObjectPath(*(x._rep->_u._referenceValue));
                 break;                 break;
  
             // Should never get here. testing complete enum             // Should never get here. testing complete enum
Line 849 
Line 525 
     {     {
         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 917 
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 952 
Line 628 
  
 Boolean CIMValue::typeCompatible(const CIMValue& x) const Boolean CIMValue::typeCompatible(const CIMValue& x) const
 { {
     return _rep->_type == x._rep->_type && _rep->_isArray == x._rep->_isArray;      return (_rep->_type == x._rep->_type &&
               _rep->_isArray == x._rep->_isArray);
   //            getArraySize() == x.getArraySize());
 } }
  
 Boolean CIMValue::isArray() const Boolean CIMValue::isArray() const
Line 972 
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
         default:         default:
Line 1059 
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<CIMReference>(arraySize));                  set(Array<CIMObjectPath>(arraySize));
                 break;                 break;
             default:             default:
                 throw CIMValueInvalidType();                 throw CIMValueInvalidType();
Line 1126 
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(CIMReference());                  set(CIMObjectPath());
                 break;                 break;
             default:             default:
                 throw CIMValueInvalidType();                 throw CIMValueInvalidType();
Line 1200 
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 1208 
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 1216 
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 1224 
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 1232 
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 1240 
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 1248 
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 1256 
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 1264 
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 1272 
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 1280 
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 1288 
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 1296 
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;  
 }  
   
 void CIMValue::set(const char* x)  
 {  
     set(String(x));  
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
Line 1310 
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;
 } }
  
 void CIMValue::set(const CIMReference& x)  void CIMValue::set(const CIMObjectPath& x)
 { {
     clear();     clear();
     _rep->_u._referenceValue = new CIMReference(x);      _rep->_u._referenceValue = new CIMObjectPath(x);
     _rep->_type = CIMType::REFERENCE;      _rep->_type = CIMTYPE_REFERENCE;
     _rep->_isNull = false;     _rep->_isNull = false;
 } }
  
 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 1334 
Line 1006 
 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 1343 
Line 1015 
 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 1352 
Line 1024 
 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 1361 
Line 1033 
 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 1370 
Line 1042 
 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 1379 
Line 1051 
 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 1388 
Line 1060 
 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 1397 
Line 1069 
 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 1406 
Line 1078 
 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 1415 
Line 1087 
 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 1424 
Line 1096 
 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 1433 
Line 1105 
 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 1442 
Line 1114 
 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;
 } }
  
 void CIMValue::set(const Array<CIMReference>& 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;
 } }
  
 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 1467 
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 1475 
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 1483 
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 1491 
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 1499 
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 1507 
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 1515 
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 1523 
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 1531 
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 1539 
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 1547 
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 1555 
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 1563 
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;
 } }
  
 void CIMValue::get(CIMReference& 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 1579 
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.set(_rep->_u._booleanArray);      x = *_rep->_u._booleanArray;
 } }
  
 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.set(_rep->_u._uint8Array);      x = *_rep->_u._uint8Array;
 } }
  
 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.set(_rep->_u._sint8Array);      x = *_rep->_u._sint8Array;
 } }
  
 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.set(_rep->_u._uint16Array);      x = *_rep->_u._uint16Array;
 } }
  
 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.set(_rep->_u._sint16Array);      x = *_rep->_u._sint16Array;
 } }
  
 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.set(_rep->_u._uint32Array);      x = *_rep->_u._uint32Array;
 } }
  
 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.set(_rep->_u._sint32Array);      x = *_rep->_u._sint32Array;
 } }
  
 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.set(_rep->_u._uint64Array);      x = *_rep->_u._uint64Array;
 } }
  
 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.set(_rep->_u._sint64Array);      x = *_rep->_u._sint64Array;
 } }
  
 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.set(_rep->_u._real32Array);      x = *_rep->_u._real32Array;
 } }
  
 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.set(_rep->_u._real64Array);      x = *_rep->_u._real64Array;
 } }
  
 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.set(_rep->_u._char16Array);      x = *_rep->_u._char16Array;
 } }
  
 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.set(_rep->_u._stringArray);      x = *_rep->_u._stringArray;
 } }
  
 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.set(_rep->_u._dateTimeArray);      x = *_rep->_u._dateTimeArray;
 } }
  
 void CIMValue::get(Array<CIMReference>& 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.set(_rep->_u._referenceArray);      x = *_rep->_u._referenceArray;
 } }
  
 void CIMValue::toXml(Array<Sint8>& out) const  Boolean CIMValue::equal(const CIMValue& x) const
 { {
     /* If the CIMValue is Null, no element is returned.      if (!typeCompatible(x))
      Note that it output absolutely nothing. This works for          return false;
      everything except qualifiers where the value tag is required in  
      any case per the XML specification  
   
      The DMTF has approved a change to the XML Specification  
      that extends the XML Definition to allow the  
      specification of NULL qualifier values. (CR812)  
   
      The definition of the ELEMENT QUALIFIER is now  
      defined as ...  
   
      <!ELEMENT QUALIFIER ((VALUE|VALUE.ARRAY)?)>  
  
     */      if (_rep->_isNull != x._rep->_isNull)
           return false;
  
     if (_rep->_isNull)  
     {  
         return;  
     }  
     if (_rep->_isArray)     if (_rep->_isArray)
     {     {
         switch (_rep->_type)         switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
             {                  return (*_rep->_u._booleanArray) ==
                 _toXml(out, _rep->_u._booleanArray->data(),                      (*x._rep->_u._booleanArray);
                             _rep->_u._booleanArray->size);  
                 // ATTN-RK-P3-20020220: Is there a reason to do it this way?              case CIMTYPE_UINT8:
                 //out << "<VALUE.ARRAY>\n";                  return (*_rep->_u._uint8Array) ==
                 //for (Uint32 i=0, n = _rep->_u._booleanArray->size; i<n; i++)                      (*x._rep->_u._uint8Array);
                 //{  
                 //    out << "<VALUE>";              case CIMTYPE_SINT8:
                 //    _toXml(out, Boolean(_rep->_u._booleanArray->data()[i]));                  return (*_rep->_u._sint8Array) ==
                 //    out << "</VALUE>\n";                      (*x._rep->_u._sint8Array);
                 //}  
                 //out << "</VALUE.ARRAY>\n";              case CIMTYPE_UINT16:
                 break;                  return (*_rep->_u._uint16Array) ==
             }                      (*x._rep->_u._uint16Array);
   
             case CIMType::UINT8:              case CIMTYPE_SINT16:
                 _toXml(out, _rep->_u._uint8Array->data(),                  return (*_rep->_u._sint16Array) ==
                             _rep->_u._uint8Array->size);                      (*x._rep->_u._sint16Array);
                 break;  
               case CIMTYPE_UINT32:
             case CIMType::SINT8:                  return (*_rep->_u._uint32Array) ==
                 _toXml(out, _rep->_u._sint8Array->data(),                      (*x._rep->_u._uint32Array);
                             _rep->_u._sint8Array->size);  
                 break;              case CIMTYPE_SINT32:
                   return (*_rep->_u._sint32Array) ==
             case CIMType::UINT16:                      (*x._rep->_u._sint32Array);
                 _toXml(out, _rep->_u._uint16Array->data(),  
                             _rep->_u._uint16Array->size);              case CIMTYPE_UINT64:
                 break;                  return (*_rep->_u._uint64Array) ==
                       (*x._rep->_u._uint64Array);
             case CIMType::SINT16:  
                 _toXml(out, _rep->_u._sint16Array->data(),              case CIMTYPE_SINT64:
                             _rep->_u._sint16Array->size);                  return (*_rep->_u._sint64Array) ==
                 break;                      (*x._rep->_u._sint64Array);
   
             case CIMType::UINT32:              case CIMTYPE_REAL32:
                 _toXml(out, _rep->_u._uint32Array->data(),                  return (*_rep->_u._real32Array) ==
                             _rep->_u._uint32Array->size);                      (*x._rep->_u._real32Array);
                 break;  
               case CIMTYPE_REAL64:
             case CIMType::SINT32:                  return (*_rep->_u._real64Array) ==
                 _toXml(out, _rep->_u._sint32Array->data(),                      (*x._rep->_u._real64Array);
                             _rep->_u._sint32Array->size);  
                 break;              case CIMTYPE_CHAR16:
                   return (*_rep->_u._char16Array) ==
             case CIMType::UINT64:                      (*x._rep->_u._char16Array);
                 _toXml(out, _rep->_u._uint64Array->data(),  
                             _rep->_u._uint64Array->size);              case CIMTYPE_STRING:
                 break;                  return (*_rep->_u._stringArray) ==
                       (*x._rep->_u._stringArray);
             case CIMType::SINT64:  
                 _toXml(out, _rep->_u._sint64Array->data(),              case CIMTYPE_DATETIME:
                             _rep->_u._sint64Array->size);                  return (*_rep->_u._dateTimeArray) ==
                 break;                      (*x._rep->_u._dateTimeArray);
   
             case CIMType::REAL32:              case CIMTYPE_REFERENCE:
                 _toXml(out, _rep->_u._real32Array->data(),                  return (*_rep->_u._referenceArray) ==
                             _rep->_u._real32Array->size);                      (*x._rep->_u._referenceArray);
                 break;  
   
             case CIMType::REAL64:  
                 _toXml(out, _rep->_u._real64Array->data(),  
                             _rep->_u._real64Array->size);  
                 break;  
   
             case CIMType::CHAR16:  
                 _toXml(out, _rep->_u._char16Array->data(),  
                             _rep->_u._char16Array->size);  
                 break;  
   
             case CIMType::STRING:  
                 _toXml(out, _rep->_u._stringArray->data(),  
                             _rep->_u._stringArray->size);  
                 break;  
   
             case CIMType::DATETIME:  
                 _toXml(out, _rep->_u._dateTimeArray->data(),  
                             _rep->_u._dateTimeArray->size);  
                 break;  
   
             case CIMType::REFERENCE:  
                 _toXml(out, _rep->_u._referenceArray->data(),  
                             _rep->_u._referenceArray->size);  
                 break;  
   
             default:             default:
                 throw CIMValueInvalidType();                 throw CIMValueInvalidType();
         }         }
     }     }
     else if (_rep->_type == CIMType::REFERENCE)  
     {  
         // Has to be separate because it uses VALUE.REFERENCE tag  
         _toXml(out, *_rep->_u._referenceValue);  
     }  
     else     else
     {     {
         out << "<VALUE>";  
   
         switch (_rep->_type)         switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 _toXml(out, Boolean(_rep->_u._booleanValue != 0));                  return _rep->_u._booleanValue == x._rep->_u._booleanValue;
                 break;  
   
             case CIMType::UINT8:  
                 _toXml(out, _rep->_u._uint8Value);  
                 break;  
   
             case CIMType::SINT8:  
                 _toXml(out, _rep->_u._sint8Value);  
                 break;  
   
             case CIMType::UINT16:  
                 _toXml(out, _rep->_u._uint16Value);  
                 break;  
   
             case CIMType::SINT16:  
                 _toXml(out, _rep->_u._sint16Value);  
                 break;  
   
             case CIMType::UINT32:  
                 _toXml(out, _rep->_u._uint32Value);  
                 break;  
   
             case CIMType::SINT32:  
                 _toXml(out, _rep->_u._sint32Value);  
                 break;  
   
             case CIMType::UINT64:  
                 _toXml(out, _rep->_u._uint64Value);  
                 break;  
   
             case CIMType::SINT64:  
                 _toXml(out, _rep->_u._sint64Value);  
                 break;  
   
             case CIMType::REAL32:  
                 _toXml(out, _rep->_u._real32Value);  
                 break;  
   
             case CIMType::REAL64:  
                 _toXml(out, _rep->_u._real64Value);  
                 break;  
   
             case CIMType::CHAR16:  
                 _toXml(out, Char16(_rep->_u._char16Value));  
                 break;  
   
             case CIMType::STRING:  
                 _toXml(out, *_rep->_u._stringValue);  
                 break;  
   
             case CIMType::DATETIME:  
                 _toXml(out, *_rep->_u._dateTimeValue);  
                 break;  
             default:  
                 throw CIMValueInvalidType();  
         }  
   
         out << "</VALUE>\n";  
     }  
 }  
   
 String CIMValue::toXml() const  
 {  
     Array<Sint8> out;  
     toXml(out);  
     out.append('\0');  
     return String(out.getData());  
 }  
  
 void CIMValue::print(PEGASUS_STD(ostream) &os) const              case CIMTYPE_UINT8:
 {                  return _rep->_u._uint8Value == x._rep->_u._uint8Value;
     Array<Sint8> tmp;  
     toXml(tmp);  
     tmp.append('\0');  
     os << tmp.getData() << PEGASUS_STD(endl);  
 }  
  
 void CIMValue::toMof(Array<Sint8>& out) const              case CIMTYPE_SINT8:
 {                  return _rep->_u._sint8Value == x._rep->_u._sint8Value;
     // if the CIMValue is Null we return nothing.  
     // The alternative is to return the Null indicator.  
     if (_rep->_isNull)  
     {  
         out << "null";  
         return ;  
     }  
  
               case CIMTYPE_UINT16:
                   return _rep->_u._uint16Value == x._rep->_u._uint16Value;
  
     if (_rep->_isArray)              case CIMTYPE_SINT16:
     {                  return _rep->_u._sint16Value == x._rep->_u._sint16Value;
         switch (_rep->_type)  
         {  
             case CIMType::BOOLEAN:  
             {  
                 _toMof(out, _rep->_u._booleanArray->data(),  
                             _rep->_u._booleanArray->size);  
                 break;  
             }  
             case CIMType::UINT8:  
                 _toMof(out, _rep->_u._uint8Array->data(),  
                             _rep->_u._uint8Array->size);  
                 break;  
   
             case CIMType::SINT8:  
                 _toMof(out, _rep->_u._sint8Array->data(),  
                             _rep->_u._sint8Array->size);  
                 break;  
   
             case CIMType::UINT16:  
                 _toMof(out, _rep->_u._uint16Array->data(),  
                             _rep->_u._uint16Array->size);  
                 break;  
  
             case CIMType::SINT16:              case CIMTYPE_UINT32:
                 _toMof(out, _rep->_u._sint16Array->data(),                  return _rep->_u._uint32Value == x._rep->_u._uint32Value;
                             _rep->_u._sint16Array->size);  
                 break;  
  
             case CIMType::UINT32:              case CIMTYPE_SINT32:
                 _toMof(out, _rep->_u._uint32Array->data(),                  return _rep->_u._sint32Value == x._rep->_u._sint32Value;
                             _rep->_u._uint32Array->size);  
                 break;  
  
             case CIMType::SINT32:              case CIMTYPE_UINT64:
                 _toMof(out, _rep->_u._sint32Array->data(),                  return _rep->_u._uint64Value == x._rep->_u._uint64Value;
                             _rep->_u._sint32Array->size);  
                 break;  
  
             case CIMType::UINT64:              case CIMTYPE_SINT64:
                 _toMof(out, _rep->_u._uint64Array->data(),                  return _rep->_u._sint64Value == x._rep->_u._sint64Value;
                             _rep->_u._uint64Array->size);  
                 break;  
  
             case CIMType::SINT64:              case CIMTYPE_REAL32:
                 _toMof(out, _rep->_u._sint64Array->data(),                  return _rep->_u._real32Value == x._rep->_u._real32Value;
                             _rep->_u._sint64Array->size);  
                 break;  
  
             case CIMType::REAL32:              case CIMTYPE_REAL64:
                 _toMof(out, _rep->_u._real32Array->data(),                  return _rep->_u._real64Value == x._rep->_u._real64Value;
                             _rep->_u._real32Array->size);  
                 break;  
  
             case CIMType::REAL64:              case CIMTYPE_CHAR16:
                 _toMof(out, _rep->_u._real64Array->data(),                  return _rep->_u._char16Value == x._rep->_u._char16Value;
                             _rep->_u._real64Array->size);  
                 break;  
  
             case CIMType::CHAR16:              case CIMTYPE_STRING:
                 _toMof(out, _rep->_u._char16Array->data(),                  return String::equal(*_rep->_u._stringValue,
                             _rep->_u._char16Array->size);                                       *x._rep->_u._stringValue);
                 break;  
   
             case CIMType::STRING:  
                 _toMof(out, _rep->_u._stringArray->data(),  
                             _rep->_u._stringArray->size);  
                 break;  
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 _toMof(out, _rep->_u._dateTimeArray->data(),                  return *_rep->_u._dateTimeValue == *x._rep->_u._dateTimeValue;
                             _rep->_u._dateTimeArray->size);  
                 break;  
  
             case CIMType::REFERENCE:              case CIMTYPE_REFERENCE:
                 _toMof(out, _rep->_u._referenceArray->data(),                  return *_rep->_u._referenceValue ==
                             _rep->_u._referenceArray->size);                      *x._rep->_u._referenceValue;
                 break;  
  
             default:             default:
                 throw CIMValueInvalidType();                 throw CIMValueInvalidType();
         }         }
     }     }
     else  
     {  
         switch (_rep->_type)  
         {  
             case CIMType::BOOLEAN:  
                 _toMof(out, Boolean(_rep->_u._booleanValue != 0));  
                 break;  
   
             case CIMType::UINT8:  
                 _toMof(out, _rep->_u._uint8Value);  
                 break;  
   
             case CIMType::SINT8:  
                 _toMof(out, _rep->_u._sint8Value);  
                 break;  
   
             case CIMType::UINT16:  
                 _toMof(out, _rep->_u._uint16Value);  
                 break;  
   
             case CIMType::SINT16:  
                 _toMof(out, _rep->_u._sint16Value);  
                 break;  
   
             case CIMType::UINT32:  
                 _toMof(out, _rep->_u._uint32Value);  
                 break;  
   
             case CIMType::SINT32:  
                 _toMof(out, _rep->_u._sint32Value);  
                 break;  
   
             case CIMType::UINT64:  
                 _toMof(out, _rep->_u._uint64Value);  
                 break;  
   
             case CIMType::SINT64:  
                 _toMof(out, _rep->_u._sint64Value);  
                 break;  
  
             case CIMType::REAL32:      // Unreachable!
                 _toMof(out, _rep->_u._real32Value);      return false;
                 break;  
   
             case CIMType::REAL64:  
                 _toMof(out, _rep->_u._real64Value);  
                 break;  
   
             case CIMType::CHAR16:  
                 _toMof(out, Char16(_rep->_u._char16Value));  
                 break;  
   
             case CIMType::STRING:  
                 _toMof(out, *_rep->_u._stringValue);  
                 break;  
   
             case CIMType::DATETIME:  
                 _toMof(out, *_rep->_u._dateTimeValue);  
                 break;  
   
             case CIMType::REFERENCE:  
                 _toMof(out, *_rep->_u._referenceValue);  
                 break;  
   
             default:  
                 throw CIMValueInvalidType();  
         }  
     }  
 } }
  
 String CIMValue::toString() const String CIMValue::toString() const
Line 2086 
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++)
                 {                 {
                     _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 2175 
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;
  
Line 2247 
Line 1680 
  
 Boolean operator==(const CIMValue& x, const CIMValue& y) Boolean operator==(const CIMValue& x, const CIMValue& y)
 { {
     if (!x.typeCompatible(y))      return x.equal(y);
         return false;  
   
     if (x._rep->_isNull != y._rep->_isNull)  
         return false;  
   
     if (x._rep->_isArray)  
     {  
         switch (x._rep->_type)  
         {  
             case CIMType::BOOLEAN:  
                 return Array<Boolean>(x._rep->_u._booleanArray) ==  
                     Array<Boolean>(y._rep->_u._booleanArray);  
   
             case CIMType::UINT8:  
                 return Array<Uint8>(x._rep->_u._uint8Array) ==  
                     Array<Uint8>(y._rep->_u._uint8Array);  
   
             case CIMType::SINT8:  
                 return Array<Sint8>(x._rep->_u._sint8Array) ==  
                     Array<Sint8>(y._rep->_u._sint8Array);  
   
             case CIMType::UINT16:  
                 return Array<Uint16>(x._rep->_u._uint16Array) ==  
                     Array<Uint16>(y._rep->_u._uint16Array);  
   
             case CIMType::SINT16:  
                 return Array<Sint16>(x._rep->_u._sint16Array) ==  
                     Array<Sint16>(y._rep->_u._sint16Array);  
   
             case CIMType::UINT32:  
                 return Array<Uint32>(x._rep->_u._uint32Array) ==  
                     Array<Uint32>(y._rep->_u._uint32Array);  
   
             case CIMType::SINT32:  
                 return Array<Sint32>(x._rep->_u._sint32Array) ==  
                     Array<Sint32>(y._rep->_u._sint32Array);  
   
             case CIMType::UINT64:  
                 return Array<Uint64>(x._rep->_u._uint64Array) ==  
                     Array<Uint64>(y._rep->_u._uint64Array);  
   
             case CIMType::SINT64:  
                 return Array<Sint64>(x._rep->_u._sint64Array) ==  
                     Array<Sint64>(y._rep->_u._sint64Array);  
   
             case CIMType::REAL32:  
                 return Array<Real32>(x._rep->_u._real32Array) ==  
                     Array<Real32>(y._rep->_u._real32Array);  
   
             case CIMType::REAL64:  
                 return Array<Real64>(x._rep->_u._real64Array) ==  
                     Array<Real64>(y._rep->_u._real64Array);  
   
             case CIMType::CHAR16:  
                 return Array<Char16>(x._rep->_u._char16Array) ==  
                     Array<Char16>(y._rep->_u._char16Array);  
   
             case CIMType::STRING:  
                 return Array<String>(x._rep->_u._stringArray) ==  
                     Array<String>(y._rep->_u._stringArray);  
   
             case CIMType::DATETIME:  
                 return Array<CIMDateTime>(x._rep->_u._dateTimeArray) ==  
                     Array<CIMDateTime>(y._rep->_u._dateTimeArray);  
   
             case CIMType::REFERENCE:  
                 return Array<CIMReference>(x._rep->_u._referenceArray) ==  
                     Array<CIMReference>(y._rep->_u._referenceArray);  
             default:  
                 throw CIMValueInvalidType();  
         }  
     }  
     else  
     {  
         switch (x._rep->_type)  
         {  
             case CIMType::BOOLEAN:  
                 return x._rep->_u._booleanValue == y._rep->_u._booleanValue;  
   
             case CIMType::UINT8:  
                 return x._rep->_u._uint8Value == y._rep->_u._uint8Value;  
   
             case CIMType::SINT8:  
                 return x._rep->_u._sint8Value == y._rep->_u._sint8Value;  
   
             case CIMType::UINT16:  
                 return x._rep->_u._uint16Value == y._rep->_u._uint16Value;  
   
             case CIMType::SINT16:  
                 return x._rep->_u._sint16Value == y._rep->_u._sint16Value;  
   
             case CIMType::UINT32:  
                 return x._rep->_u._uint32Value == y._rep->_u._uint32Value;  
   
             case CIMType::SINT32:  
                 return x._rep->_u._sint32Value == y._rep->_u._sint32Value;  
   
             case CIMType::UINT64:  
                 return x._rep->_u._uint64Value == y._rep->_u._uint64Value;  
   
             case CIMType::SINT64:  
                 return x._rep->_u._sint64Value == y._rep->_u._sint64Value;  
   
             case CIMType::REAL32:  
                 return x._rep->_u._real32Value == y._rep->_u._real32Value;  
   
             case CIMType::REAL64:  
                 return x._rep->_u._real64Value == y._rep->_u._real64Value;  
   
             case CIMType::CHAR16:  
                 return x._rep->_u._char16Value == y._rep->_u._char16Value;  
   
             case CIMType::STRING:  
                 return String::equal(*x._rep->_u._stringValue,  
                                      *y._rep->_u._stringValue);  
   
             case CIMType::DATETIME:  
                 return *x._rep->_u._dateTimeValue == *y._rep->_u._dateTimeValue;  
   
             case CIMType::REFERENCE:  
                 return *x._rep->_u._referenceValue ==  
                     *y._rep->_u._referenceValue;  
   
             default:  
                 throw CIMValueInvalidType();  
         }  
     }  
   
     // Unreachable!  
     return false;  
 } }
  
 Boolean operator!=(const CIMValue& x, const CIMValue& y) Boolean operator!=(const CIMValue& x, const CIMValue& y)
 { {
     return !operator==(x, y);      return !x.equal(y);
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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