(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.24 and 1.49.4.1

version 1.24, 2002/04/01 19:06:03 version 1.49.4.1, 2004/11/12 17:48:28
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2003////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development
   // Company, L. P., IBM Corp., The Open Group, Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
   // IBM Corp.; EMC Corporation, The Open Group.
 // //
 // 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 27 
 // //
 // 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)
   //              Adriann Schuur (schuur@de.ibm.com) PEP 164
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <cstring> #include <cstring>
 #include <cstdio> #include <cstdio>
 #include <cassert>  
 #include <cctype> #include <cctype>
 #include "CIMValue.h" #include "CIMValue.h"
   #include "Union.h"
 #include "Indentor.h" #include "Indentor.h"
 #include "Exception.h"  
 #include "XmlWriter.h" #include "XmlWriter.h"
   #include "CommonUTF.h"
   
   #include "CIMValueRep.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 42 
Line 50 
 # 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:  
 //  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 // Too complicated.  Commented out in favor of sprintf("%lld"/"%llu").  
 #if 0  
 //------------------------------------------------------------------------------  
 // //
 // _SignedIntToStr()  // _toString routines:
 // //
 //------------------------------------------------------------------------------  ////////////////////////////////////////////////////////////////////////////////
   
 static void _SignedIntToStr(Sint64 x, char* result)  
 {  
     if (!result)  
         return;  
  
     if (x == 0)  inline void _toString(Array<Sint8>& out, Boolean x)
     {     {
         result[0] = '0';      XmlWriter::append(out, x);
         result[1] = '\0';  
         return;  
     }     }
  
     char buffer[32];  inline void _toString(Array<Sint8>& out, Uint8 x) { XmlWriter::append(out, Uint32(x)); }
     Uint32 len = 0;  inline void _toString(Array<Sint8>& out, Sint8 x) { XmlWriter::append(out, Sint32(x)); }
     Boolean negative = false;  inline void _toString(Array<Sint8>& out, Uint16 x) { XmlWriter::append(out, Uint32(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); }
   inline void _toString(Array<Sint8>& out, Sint32 x) { XmlWriter::append(out, x); }
   inline void _toString(Array<Sint8>& out, Uint64 x) { XmlWriter::append(out, x); }
   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); }
  
     while (x)  inline void _toString(Array<Sint8>& out, Char16 x)
     {     {
         Sint32 r = x % 10;      // We need to convert the Char16 to UTF8 then append the UTF8
         x = x / 10;      // character into the array.
       // NOTE: The UTF8 character could be several bytes long.
       // WARNING: This function will put in replacement character for
       // all characters that have surogate pairs.
   
       char str[6];
       memset(str,0x00,sizeof(str));
       char* charIN = (char *)&x;
   
       const Uint16 *strsrc = (Uint16 *)charIN;
       Uint16 *endsrc = (Uint16 *)&charIN[1];
   
       Uint8 *strtgt = (Uint8 *)str;
       Uint8 *endtgt = (Uint8 *)&str[5];
   
       UTF16toUTF8(&strsrc,
                   endsrc,
                   &strtgt,
                   endtgt);
  
         if (r < 0)      out.append((Sint8 *)str, UTF_8_COUNT_TRAIL_BYTES(str[0]) +1);
         {  
             r = -r;  
             negative = true;  
         }         }
  
         buffer[len++] = r + '0';  inline void _toString(Array<Sint8>& out, const String& x)
   {
       out << x;
     }     }
  
     buffer[len] = '\0';  inline void _toString(Array<Sint8>& out, const CIMDateTime& x)
   {
     // If buffer was negative, prepend sign:      out << x.toString();
   
     char* q = result;  
   
     if (negative)  
         *q++ = '-';  
   
     // Reverse the buffer:  
   
     char* p = &buffer[len];  
   
     while (len--)  
         *q++ = *--p;  
   
     *q++ = '\0';  
 } }
  
 //------------------------------------------------------------------------------  inline void _toString(Array<Sint8>& out, const CIMObjectPath& x)
 //  
 // _UnsignedIntToStr()  
 //  
 //------------------------------------------------------------------------------  
   
 static void _UnsignedIntToStr(Uint64 x, char* result)  
 { {
     if (!result)      out << x.toString();
         return;  }
  
     if (x == 0)  inline void _toString(Array<Sint8>& out, const CIMObject& x)
     {     {
         result[0] = '0';      out << x.toString();
         result[1] = '\0';  
         return;  
     }     }
  
     char buffer[32];  template<class T>
     Uint32 len = 0;  void _toString(Array<Sint8>& out, const T* p, Uint32 size)
   
     while (x)  
     {     {
         Uint32 r = x % 10;      while (size--)
         x = x / 10;      {
           _toString(out, *p++);
         buffer[len++] = r + '0';          out << " ";
     }     }
   
     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:  // CIMValue
 // //
 //------------------------------------------------------------------------------  ////////////////////////////////////////////////////////////////////////////////
  
 inline void _toString(Array<Sint8>& out, Boolean x)  CIMValue::CIMValue()
 { {
     out << (x ? "TRUE" : "FALSE");      _rep = new CIMValueRep();
 } }
  
 inline void _toXml(Array<Sint8>& out, Boolean x) { _toString(out, x); }  CIMValue::CIMValue(CIMType type, Boolean isArray, Uint32 arraySize)
 inline void _toMof(Array<Sint8>& out, Boolean x) { _toString(out, x); }  
   
 inline void _integerToString(Array<Sint8>& out, Sint32 x)  
 { {
     char buffer[32];      _rep = new CIMValueRep();
     sprintf(buffer, "%d", x);      setNullValue(type, isArray, arraySize);
     out << (char*)buffer;  
 } }
  
 inline void _unsignedIntegerToString(Array<Sint8>& out, Uint32 x)  CIMValue::CIMValue(Boolean x)
 { {
     char buffer[32];      _rep = new CIMValueRep();
     sprintf(buffer, "%u", x);      set(x);
     out << (char*)buffer;  
 } }
  
 inline void _toString(Array<Sint8>& out, Uint8 x) { _unsignedIntegerToString(out, x); }  CIMValue::CIMValue(Uint8 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      _rep = new CIMValueRep();
     // I know I shouldn't put platform flags here, but the other was is too hard      set(x);
 #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); }  CIMValue::CIMValue(Sint8 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      _rep = new CIMValueRep();
     // I know I shouldn't put platform flags here, but the other was is too hard      set(x);
 #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); }  CIMValue::CIMValue(Uint16 x)
 inline void _toMof(Array<Sint8>& out, Sint64 x) { _toString(out, x); }  
   
 void _toString(Array<Sint8>& out, Real64 x)  
 { {
     char buffer[128];      _rep = new CIMValueRep();
     // %e gives '[-]m.dddddde+/-xx', which seems compatible with CIM/XML spec      set(x);
     sprintf(buffer, "%e", x);  
     out << buffer;  
 } }
  
 inline void _toXml(Array<Sint8>& out, Real64 x) { _toString(out, x); }  CIMValue::CIMValue(Sint16 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)  
 { {
     // ATTN: How to convert 16-bit characters to printable form?      _rep = new CIMValueRep();
     out.append(Sint8(x));      set(x);
 } }
 inline void _toXml(Array<Sint8>& out, Char16 x)  
   CIMValue::CIMValue(Uint32 x)
 { {
     XmlWriter::appendSpecial(out, x);      _rep = new CIMValueRep();
       set(x);
 } }
 inline void _toMof(Array<Sint8>& out, Char16 x)  
   CIMValue::CIMValue(Sint32 x)
 { {
     XmlWriter::appendSpecial(out, x);      _rep = new CIMValueRep();
       set(x);
 } }
  
 inline void _toString(Array<Sint8>& out, const String& x)  CIMValue::CIMValue(Uint64 x)
 { {
     out << x;      _rep = new CIMValueRep();
       set(x);
 } }
  
 inline void _toXml(Array<Sint8>& out, const String& x)  CIMValue::CIMValue(Sint64 x)
 { {
     XmlWriter::appendSpecial(out, x);      _rep = new CIMValueRep();
       set(x);
 } }
  
 /** _toMof Internal function to convert the string back  CIMValue::CIMValue(Real32 x)
     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 '\\':      _rep = new CIMValueRep();
                 out.append("\\\\",2);      set(x);
                 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));  
         }         }
  
     }  CIMValue::CIMValue(Real64 x)
     out << "\"";  {
       _rep = new CIMValueRep();
       set(x);
 } }
  
 inline void _toString(Array<Sint8>& out, const CIMDateTime& x)  CIMValue::CIMValue(const Char16& x)
 { {
     out << x.getString();      _rep = new CIMValueRep();
       set(x);
 } }
  
 inline void _toXml(Array<Sint8>& out, const CIMDateTime& x) { _toString(out, x); }  CIMValue::CIMValue(const String& 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();      _rep = new CIMValueRep();
       set(x);
 } }
 inline void _toXml(Array<Sint8>& out, const CIMReference& x)  
   CIMValue::CIMValue(const CIMDateTime& x)
 { {
     x.toXml(out);      _rep = new CIMValueRep();
       set(x);
 } }
 inline void _toMof(Array<Sint8>& out, const CIMReference& x)  
   CIMValue::CIMValue(const CIMObjectPath& x)
 { {
     x.toMof(out);      _rep = new CIMValueRep();
       set(x);
 } }
  
 template<class T>  CIMValue::CIMValue(const CIMObject& x)
 void _toString(Array<Sint8>& out, const T* p, Uint32 size)  
 {  
     while (size--)  
     {     {
         _toString(out, *p++);      _rep = new CIMValueRep();
         out << " ";      set(x);
     }  
 } }
  
 void _toXml(Array<Sint8>& out, const CIMReference* p, Uint32 size)  CIMValue::CIMValue(const Array<Boolean>& x)
 {  
     out << "<VALUE.REFARRAY>\n";  
     while (size--)  
     {     {
         _toXml(out, *p++);      _rep = new CIMValueRep();
     }      set(x);
     out << "</VALUE.REFARRAY>\n";  
 } }
  
 template<class T>  CIMValue::CIMValue(const Array<Uint8>& x)
 void _toXml(Array<Sint8>& out, const T* p, Uint32 size)  
 { {
     out << "<VALUE.ARRAY>\n";      _rep = new CIMValueRep();
       set(x);
   }
  
     while (size--)  CIMValue::CIMValue(const Array<Sint8>& x)
     {     {
         out << "<VALUE>";      _rep = new CIMValueRep();
       set(x);
   }
  
         _toXml(out, *p++);  CIMValue::CIMValue(const Array<Uint16>& x)
   {
       _rep = new CIMValueRep();
       set(x);
   }
  
         out << "</VALUE>\n";  CIMValue::CIMValue(const Array<Sint16>& x)
   {
       _rep = new CIMValueRep();
       set(x);
     }     }
  
     out << "</VALUE.ARRAY>\n";  CIMValue::CIMValue(const Array<Uint32>& x)
   {
       _rep = new CIMValueRep();
       set(x);
 } }
 /** _toMof Array -  
     arrayInitializer  = "{" constantValue*( "," constantValue)"}"  
  
 */  CIMValue::CIMValue(const Array<Sint32>& x)
 template<class T>  
 void _toMof(Array<Sint8>& out, const T* p, Uint32 size)  
 { {
     Boolean isFirstEntry = true;      _rep = new CIMValueRep();
     // if there are any entries in the array output them      set(x);
     if (size)  }
   
   CIMValue::CIMValue(const Array<Uint64>& x)
     {     {
         out << "{";      _rep = new CIMValueRep();
         while (size--)      set(x);
   }
   
   CIMValue::CIMValue(const Array<Sint64>& x)
         {         {
             // Put comma on all but first entry.      _rep = new CIMValueRep();
             if (!isFirstEntry)      set(x);
   }
   
   CIMValue::CIMValue(const Array<Real32>& x)
             {             {
                 out << ", ";      _rep = new CIMValueRep();
       set(x);
             }             }
             isFirstEntry = false;  
             _toMof(out, *p++);  CIMValue::CIMValue(const Array<Real64>& x)
   {
       _rep = new CIMValueRep();
       set(x);
         }         }
         out << "}";  
  
   CIMValue::CIMValue(const Array<Char16>& x)
   {
       _rep = new CIMValueRep();
       set(x);
     }     }
   
   CIMValue::CIMValue(const Array<String>& x)
   {
       _rep = new CIMValueRep();
       set(x);
 } }
  
 ////////////////////////////////////////////////////////////////////////////////  CIMValue::CIMValue(const Array<CIMDateTime>& x)
 //  {
 // CIMValue      _rep = new CIMValueRep();
 //      set(x);
 ////////////////////////////////////////////////////////////////////////////////  }
  
 CIMValue::CIMValue()  CIMValue::CIMValue(const Array<CIMObjectPath>& x)
 { {
     _init();      _rep = new CIMValueRep();
       set(x);
 } }
  
 CIMValue::CIMValue(CIMType type, Boolean isArray, Uint32 arraySize)  CIMValue::CIMValue(const Array<CIMObject>& x)
 { {
     _init();      _rep = new CIMValueRep();
     setNullValue(type, isArray, arraySize);      set(x);
 } }
  
 CIMValue::CIMValue(const CIMValue& x) CIMValue::CIMValue(const CIMValue& x)
 { {
     _init();      _rep = new CIMValueRep();
     assign(x);     assign(x);
 } }
  
 CIMValue::~CIMValue() CIMValue::~CIMValue()
 { {
     clear();     clear();
       delete _rep;
   }
   
   CIMValue& CIMValue::operator=(const CIMValue& x)
   {
       assign(x);
       return *this;
 } }
  
 void CIMValue::assign(const CIMValue& x) void CIMValue::assign(const CIMValue& x)
Line 466 
Line 364 
  
     clear();     clear();
  
     _type = x._type;      _rep->_type = x._rep->_type;
     _isArray = x._isArray;      _rep->_isArray = x._rep->_isArray;
     _isNull = x._isNull;      _rep->_isNull = x._rep->_isNull;
     _u._voidPtr = 0;  
  
     if (_isArray)      if (_rep->_isArray)
     {     {
         switch (_type)          switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 _Inc(_u._booleanArray = x._u._booleanArray);                  _rep->_u._booleanArray =
                       new Array<Boolean>(*(x._rep->_u._booleanArray));
                   break;
   
               case CIMTYPE_UINT8:
                   _rep->_u._uint8Array =
                       new Array<Uint8>(*(x._rep->_u._uint8Array));
                 break;                 break;
  
             case CIMType::UINT8:              case CIMTYPE_SINT8:
                 _Inc(_u._uint8Array = x._u._uint8Array);                  _rep->_u._sint8Array =
                       new Array<Sint8>(*(x._rep->_u._sint8Array));
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_UINT16:
                 _Inc(_u._sint8Array = x._u._sint8Array);                  _rep->_u._uint16Array =
                       new Array<Uint16>(*(x._rep->_u._uint16Array));
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_SINT16:
                 _Inc(_u._uint16Array = x._u._uint16Array);                  _rep->_u._sint16Array =
                       new Array<Sint16>(*(x._rep->_u._sint16Array));
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_UINT32:
                 _Inc(_u._sint16Array = x._u._sint16Array);                  _rep->_u._uint32Array =
                       new Array<Uint32>(*(x._rep->_u._uint32Array));
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_SINT32:
                 _Inc(_u._uint32Array = x._u._uint32Array);                  _rep->_u._sint32Array =
                       new Array<Sint32>(*(x._rep->_u._sint32Array));
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_UINT64:
                 _Inc(_u._sint32Array = x._u._sint32Array);                  _rep->_u._uint64Array =
                       new Array<Uint64>(*(x._rep->_u._uint64Array));
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_SINT64:
                 _Inc(_u._uint64Array = x._u._uint64Array);                  _rep->_u._sint64Array =
                       new Array<Sint64>(*(x._rep->_u._sint64Array));
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_REAL32:
                 _Inc(_u._sint64Array = x._u._sint64Array);                  _rep->_u._real32Array =
                       new Array<Real32>(*(x._rep->_u._real32Array));
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL64:
                 _Inc(_u._real32Array = x._u._real32Array);                  _rep->_u._real64Array =
                       new Array<Real64>(*(x._rep->_u._real64Array));
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_CHAR16:
                 _Inc(_u._real64Array = x._u._real64Array);                  _rep->_u._char16Array =
                       new Array<Char16>(*(x._rep->_u._char16Array));
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_STRING:
                 _Inc(_u._char16Array = x._u._char16Array);                  _rep->_u._stringArray =
                       new Array<String>(*(x._rep->_u._stringArray));
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_DATETIME:
                 _Inc(_u._stringArray = x._u._stringArray);                  _rep->_u._dateTimeArray =
                       new Array<CIMDateTime>(*(x._rep->_u._dateTimeArray));
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_REFERENCE:
                 _Inc(_u._dateTimeArray = x._u._dateTimeArray);                  _rep->_u._referenceArray =
                       new Array<CIMObjectPath>(*(x._rep->_u._referenceArray));
                 break;                 break;
  
             case CIMType::REFERENCE:          case CIMTYPE_OBJECT:
                 _Inc(_u._referenceArray = x._u._referenceArray);                  _rep->_u._cimobjectArray =
                       new Array<CIMObject>(*(x._rep->_u._cimobjectArray));
                 break;                 break;
   
             default:             default:
                 throw CIMValueInvalidType();                  PEGASUS_ASSERT(false);
         }         }
     }     }
     else     else
     {     {
         switch (_type)          switch (_rep->_type)
         {         {
             case CIMType::NONE:              case CIMTYPE_BOOLEAN:
                   _rep->_u._booleanValue = x._rep->_u._booleanValue;
                 break;                 break;
  
             case CIMType::BOOLEAN:              case CIMTYPE_UINT8:
                 _u._booleanValue = x._u._booleanValue;                  _rep->_u._uint8Value = x._rep->_u._uint8Value;
                 break;                 break;
  
             case CIMType::UINT8:              case CIMTYPE_SINT8:
                 _u._uint8Value = x._u._uint8Value;                  _rep->_u._sint8Value = x._rep->_u._sint8Value;
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_UINT16:
                 _u._sint8Value = x._u._sint8Value;                  _rep->_u._uint16Value = x._rep->_u._uint16Value;
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_SINT16:
                 _u._uint16Value = x._u._uint16Value;                  _rep->_u._sint16Value = x._rep->_u._sint16Value;
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_UINT32:
                 _u._sint16Value = x._u._sint16Value;                  _rep->_u._uint32Value = x._rep->_u._uint32Value;
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_SINT32:
                 _u._uint32Value = x._u._uint32Value;                  _rep->_u._sint32Value = x._rep->_u._sint32Value;
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_UINT64:
                 _u._sint32Value = x._u._sint32Value;                  _rep->_u._uint64Value = x._rep->_u._uint64Value;
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_SINT64:
                 _u._uint64Value = x._u._uint64Value;                  _rep->_u._sint64Value = x._rep->_u._sint64Value;
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_REAL32:
                 _u._sint64Value = x._u._sint64Value;                  _rep->_u._real32Value = x._rep->_u._real32Value;
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL64:
                 _u._real32Value = x._u._real32Value;                  _rep->_u._real64Value = x._rep->_u._real64Value;
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_CHAR16:
                 _u._real64Value = x._u._real64Value;                  _rep->_u._char16Value = x._rep->_u._char16Value;
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_STRING:
                 _u._char16Value = x._u._char16Value;                  _rep->_u._stringValue = new String(*(x._rep->_u._stringValue));
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_DATETIME:
                 _u._stringValue = new String(*(x._u._stringValue));                  _rep->_u._dateTimeValue =
                       new CIMDateTime(*(x._rep->_u._dateTimeValue));
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_REFERENCE:
                 _u._dateTimeValue = new CIMDateTime(*(x._u._dateTimeValue));                  _rep->_u._referenceValue =
                       new CIMObjectPath(*(x._rep->_u._referenceValue));
                 break;                 break;
  
             case CIMType::REFERENCE:              case CIMTYPE_OBJECT:
                 _u._referenceValue                  _rep->_u._cimobjectValue =
                     = new CIMReference(*(x._u._referenceValue));                      new CIMObject(x._rep->_u._cimobjectValue->clone());
                 break;                 break;
  
             // Should never get here. testing complete enum             // Should never get here. testing complete enum
             default:             default:
                 throw CIMValueInvalidType();                  PEGASUS_ASSERT(false);
         }         }
     }     }
 } }
  
 Uint32 CIMValue::getArraySize() const  void CIMValue::clear()
 { {
     if (!_isArray)      if (_rep->_isArray)
         return 0;  
   
     switch (_type)  
     {     {
         case CIMType::NONE:          switch (_rep->_type)
             return 0;          {
               case CIMTYPE_BOOLEAN:
                   delete _rep->_u._booleanArray;
             break;             break;
  
         case CIMType::BOOLEAN:              case CIMTYPE_UINT8:
             return _u._booleanArray->size;                  delete _rep->_u._uint8Array;
             break;             break;
  
         case CIMType::UINT8:              case CIMTYPE_SINT8:
             return _u._uint8Array->size;                  delete _rep->_u._sint8Array;
             break;             break;
  
         case CIMType::SINT8:              case CIMTYPE_UINT16:
             return _u._sint8Array->size;                  delete _rep->_u._uint16Array;
             break;             break;
  
         case CIMType::UINT16:              case CIMTYPE_SINT16:
             return _u._uint16Array->size;                  delete _rep->_u._sint16Array;
             break;             break;
  
         case CIMType::SINT16:              case CIMTYPE_UINT32:
             return _u._sint16Array->size;                  delete _rep->_u._uint32Array;
             break;             break;
  
         case CIMType::UINT32:              case CIMTYPE_SINT32:
             return _u._uint32Array->size;                  delete _rep->_u._sint32Array;
             break;             break;
  
         case CIMType::SINT32:              case CIMTYPE_UINT64:
             return _u._sint32Array->size;                  delete _rep->_u._uint64Array;
             break;             break;
  
         case CIMType::UINT64:              case CIMTYPE_SINT64:
             return _u._uint64Array->size;                  delete _rep->_u._sint64Array;
             break;             break;
  
         case CIMType::SINT64:              case CIMTYPE_REAL32:
             return _u._sint64Array->size;                  delete _rep->_u._real32Array;
             break;             break;
  
         case CIMType::REAL32:              case CIMTYPE_REAL64:
             return _u._real32Array->size;                  delete _rep->_u._real64Array;
             break;             break;
  
         case CIMType::REAL64:              case CIMTYPE_CHAR16:
             return _u._real64Array->size;                  delete _rep->_u._char16Array;
             break;             break;
  
         case CIMType::CHAR16:              case CIMTYPE_STRING:
             return _u._char16Array->size;                  delete _rep->_u._stringArray;
             break;             break;
  
         case CIMType::STRING:              case CIMTYPE_DATETIME:
             return _u._stringArray->size;                  delete _rep->_u._dateTimeArray;
             break;             break;
  
         case CIMType::DATETIME:              case CIMTYPE_REFERENCE:
             return _u._dateTimeArray->size;                  delete _rep->_u._referenceArray;
             break;             break;
  
         case CIMType::REFERENCE:              case CIMTYPE_OBJECT:
             return _u._referenceArray->size;                  delete _rep->_u._cimobjectArray;
             break;             break;
         // Should never get here. switch on complete enum  
         default:  
             throw CIMValueInvalidType();  
     }  
  
     // Unreachable!              default:
     PEGASUS_ASSERT(false);     PEGASUS_ASSERT(false);
     return 0;  
 } }
       }
 //ATTN: P1  KS Problem with Compiler when I added the defaults to clear, the compiler      else
 // gets an exception very early.  Disabled the exceptions to keep compiler running for  
 // the minute. Note that the case statement is not complete. None missing.  
 void CIMValue::clear()  
 {  
     // ATTN: KS P1 should we be setting NULL=true here????. Right now it only  
     // clears the value component. Note that the last thing we do is init  
     // and that does the isNull=false.  
     //  
     if (_isArray)  
     {     {
         switch (_type)          switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 _Dec(_u._booleanArray);              case CIMTYPE_UINT8:
                 break;              case CIMTYPE_SINT8:
               case CIMTYPE_UINT16:
             case CIMType::UINT8:              case CIMTYPE_SINT16:
                 _Dec(_u._uint8Array);              case CIMTYPE_UINT32:
                 break;              case CIMTYPE_SINT32:
               case CIMTYPE_UINT64:
             case CIMType::SINT8:              case CIMTYPE_SINT64:
                 _Dec(_u._sint8Array);              case CIMTYPE_REAL32:
                 break;              case CIMTYPE_REAL64:
               case CIMTYPE_CHAR16:
             case CIMType::UINT16:  
                 _Dec(_u._uint16Array);  
                 break;  
   
             case CIMType::SINT16:  
                 _Dec(_u._sint16Array);  
                 break;  
   
             case CIMType::UINT32:  
                 _Dec(_u._uint32Array);  
                 break;  
   
             case CIMType::SINT32:  
                 _Dec(_u._sint32Array);  
                 break;  
   
             case CIMType::UINT64:  
                 _Dec(_u._uint64Array);  
                 break;  
   
             case CIMType::SINT64:  
                 _Dec(_u._sint64Array);  
                 break;  
   
             case CIMType::REAL32:  
                 _Dec(_u._real32Array);  
                 break;  
   
             case CIMType::REAL64:  
                 _Dec(_u._real64Array);  
                 break;  
   
             case CIMType::CHAR16:  
                 _Dec(_u._char16Array);  
                 break;  
   
             case CIMType::STRING:  
                 _Dec(_u._stringArray);  
                 break;  
   
             case CIMType::DATETIME:  
                 _Dec(_u._dateTimeArray);  
                 break;                 break;
  
             case CIMType::REFERENCE:              case CIMTYPE_STRING:
                 _Dec(_u._referenceArray);                  delete _rep->_u._stringValue;
                 break;                 break;
  
             //default:              case CIMTYPE_DATETIME:
                 //throw CIMValueInvalidType();                  delete _rep->_u._dateTimeValue;
         }  
     }  
     else  
     {  
         switch (_type)  
         {  
             case CIMType::BOOLEAN:  
             case CIMType::UINT8:  
             case CIMType::SINT8:  
             case CIMType::UINT16:  
             case CIMType::SINT16:  
             case CIMType::UINT32:  
             case CIMType::SINT32:  
             case CIMType::UINT64:  
             case CIMType::SINT64:  
             case CIMType::REAL32:  
             case CIMType::REAL64:  
             case CIMType::CHAR16:  
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_REFERENCE:
                 delete _u._stringValue;                  delete _rep->_u._referenceValue;
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_OBJECT:
                 delete _u._dateTimeValue;                  delete _rep->_u._cimobjectValue;
                 break;                 break;
  
             case CIMType::REFERENCE:              default:
                 delete _u._referenceValue;                  PEGASUS_ASSERT(false);
                 break;  
             //default:  
                 //throw CIMValueInvalidType();  
         }         }
     }     }
  
     _init();      _rep->reset();
 } }
  
 void CIMValue::toXml(Array<Sint8>& out, Boolean forceTag) const  Boolean CIMValue::typeCompatible(const CIMValue& x) const
 {  
     /* If the CIMValue is Null, no element is returned.  
      Note that it output absolutely nothing. This works for  
      everything except qualifiers where the value tag is required in  
      any case per the XML specification  
     */  
   
     if (_isNull)  
     {     {
         if (forceTag)      return (_rep->_type == x._rep->_type &&
             if (_isArray)              _rep->_isArray == x._rep->_isArray);
                 out << "<VALUE.ARRAY></VALUE.ARRAY>\n";  //            getArraySize() == x.getArraySize());
             else  
                 out << "<VALUE></VALUE>\n";  
         return;  
     }     }
     if (_isArray)  
     {  
         switch (_type)  
         {  
             case CIMType::BOOLEAN:  
             {  
                 // ATTN-RK-P3-20020220: Why can't this just use  
                 // _toXml(out, _u._booleanArray->data(), _u._booleanArray->size);  
                 // like everybody else?  
                 out << "<VALUE.ARRAY>\n";  
  
                 for (Uint32 i = 0, n = _u._booleanArray->size; i < n; i++)  Boolean CIMValue::isArray() const
                 {                 {
                     out << "<VALUE>";      return _rep->_isArray;
                     _toXml(out, Boolean(_u._booleanArray->data()[i]));  
                     out << "</VALUE>\n";  
                 }                 }
  
                 out << "</VALUE.ARRAY>\n";  Boolean CIMValue::isNull() const
                 break;  {
       return _rep->_isNull;
             }             }
  
             case CIMType::UINT8:  Uint32 CIMValue::getArraySize() const
                 _toXml(out, _u._uint8Array->data(), _u._uint8Array->size);  {
                 break;      if (!_rep->_isArray)
           return 0;
             case CIMType::SINT8:  
                 _toXml(out, _u._sint8Array->data(), _u._sint8Array->size);  
                 break;  
   
             case CIMType::UINT16:  
                 _toXml(out, _u._uint16Array->data(), _u._uint16Array->size);  
                 break;  
   
             case CIMType::SINT16:  
                 _toXml(out, _u._sint16Array->data(), _u._sint16Array->size);  
                 break;  
   
             case CIMType::UINT32:  
                 _toXml(out, _u._uint32Array->data(), _u._uint32Array->size);  
                 break;  
   
             case CIMType::SINT32:  
                 _toXml(out, _u._sint32Array->data(), _u._sint32Array->size);  
                 break;  
   
             case CIMType::UINT64:  
                 _toXml(out, _u._uint64Array->data(), _u._uint64Array->size);  
                 break;  
  
             case CIMType::SINT64:      switch (_rep->_type)
                 _toXml(out, _u._sint64Array->data(), _u._sint64Array->size);      {
           case CIMTYPE_BOOLEAN:
               return _rep->_u._booleanArray->size();
                 break;                 break;
  
             case CIMType::REAL32:          case CIMTYPE_UINT8:
                 _toXml(out, _u._real32Array->data(), _u._real32Array->size);              return _rep->_u._uint8Array->size();
                 break;                 break;
  
             case CIMType::REAL64:          case CIMTYPE_SINT8:
                 _toXml(out, _u._real64Array->data(), _u._real64Array->size);              return _rep->_u._sint8Array->size();
                 break;                 break;
  
             case CIMType::CHAR16:          case CIMTYPE_UINT16:
                 _toXml(out, _u._char16Array->data(), _u._char16Array->size);              return _rep->_u._uint16Array->size();
                 break;                 break;
  
             case CIMType::STRING:          case CIMTYPE_SINT16:
                 _toXml(out, _u._stringArray->data(), _u._stringArray->size);              return _rep->_u._sint16Array->size();
                 break;                 break;
  
             case CIMType::DATETIME:          case CIMTYPE_UINT32:
                 _toXml(out, _u._dateTimeArray->data(), _u._dateTimeArray->size);              return _rep->_u._uint32Array->size();
                 break;                 break;
  
             case CIMType::REFERENCE:          case CIMTYPE_SINT32:
                 _toXml(out, _u._referenceArray->data(),              return _rep->_u._sint32Array->size();
                             _u._referenceArray->size);  
                 break;                 break;
  
             default:          case CIMTYPE_UINT64:
                 throw CIMValueInvalidType();              return _rep->_u._uint64Array->size();
         }  
     }  
     else if (_type == CIMType::REFERENCE)  
     {  
         // Has to be separate because it uses VALUE.REFERENCE tag  
         _toXml(out, *_u._referenceValue);  
     }  
     else  
     {  
         out << "<VALUE>";  
   
         switch (_type)  
         {  
             case CIMType::BOOLEAN:  
                 _toXml(out, Boolean(_u._booleanValue != 0));  
                 break;                 break;
  
             case CIMType::UINT8:          case CIMTYPE_SINT64:
                 _toXml(out, _u._uint8Value);              return _rep->_u._sint64Array->size();
                 break;                 break;
  
             case CIMType::SINT8:          case CIMTYPE_REAL32:
                 _toXml(out, _u._sint8Value);              return _rep->_u._real32Array->size();
                 break;                 break;
  
             case CIMType::UINT16:          case CIMTYPE_REAL64:
                 _toXml(out, _u._uint16Value);              return _rep->_u._real64Array->size();
                 break;                 break;
  
             case CIMType::SINT16:          case CIMTYPE_CHAR16:
                 _toXml(out, _u._sint16Value);              return _rep->_u._char16Array->size();
                 break;                 break;
  
             case CIMType::UINT32:          case CIMTYPE_STRING:
                 _toXml(out, _u._uint32Value);              return _rep->_u._stringArray->size();
                 break;                 break;
  
             case CIMType::SINT32:          case CIMTYPE_DATETIME:
                 _toXml(out, _u._sint32Value);              return _rep->_u._dateTimeArray->size();
                 break;                 break;
  
             case CIMType::UINT64:          case CIMTYPE_REFERENCE:
                 _toXml(out, _u._uint64Value);              return _rep->_u._referenceArray->size();
                 break;                 break;
  
             case CIMType::SINT64:          case CIMTYPE_OBJECT:
                 _toXml(out, _u._sint64Value);              return _rep->_u._cimobjectArray->size();
                 break;                 break;
  
             case CIMType::REAL32:          //default:  // Handled below
                 _toXml(out, _u._real32Value);  
                 break;  
   
             case CIMType::REAL64:  
                 _toXml(out, _u._real64Value);  
                 break;  
   
             case CIMType::CHAR16:  
                 _toXml(out, Char16(_u._char16Value));  
                 break;  
   
             case CIMType::STRING:  
                 _toXml(out, *_u._stringValue);  
                 break;  
   
             case CIMType::DATETIME:  
                 _toXml(out, *_u._dateTimeValue);  
                 break;  
             default:  
                 throw CIMValueInvalidType();  
         }         }
  
         out << "</VALUE>\n";      // Unreachable!
     }      PEGASUS_ASSERT(false);
       return 0;
 } }
  
 String CIMValue::toXml(Boolean forceTag) const  CIMType CIMValue::getType() const
 { {
     Array<Sint8> out;      return CIMType(_rep->_type);
     toXml(out, forceTag);  
     out.append('\0');  
     return String(out.getData());  
 } }
  
 void CIMValue::toMof(Array<Sint8>& out) const  void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize)
 {  
     // if the CIMValue is Null we return nothing.  
     // The alternative is to return the Null indicator.  
     if (_isNull)  
     {     {
         out << "null";      clear();
         return ;  
     }  
   
  
     if (_isArray)      if (isArray)
     {  
         switch (_type)  
         {         {
             case CIMType::BOOLEAN:          switch (type)
             {             {
                 _toMof(out, _u._booleanArray->data(), _u._booleanArray->size);              case CIMTYPE_BOOLEAN:
                   set(Array<Boolean>(arraySize));
                 break;                 break;
             }  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 _toMof(out, _u._uint8Array->data(), _u._uint8Array->size);                  set(Array<Uint8>(arraySize));
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 _toMof(out, _u._sint8Array->data(), _u._sint8Array->size);                  set(Array<Sint8>(arraySize));
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 _toMof(out, _u._uint16Array->data(), _u._uint16Array->size);                  set(Array<Uint16>(arraySize));
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 _toMof(out, _u._sint16Array->data(), _u._sint16Array->size);                  set(Array<Sint16>(arraySize));
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 _toMof(out, _u._uint32Array->data(), _u._uint32Array->size);                  set(Array<Uint32>(arraySize));
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 _toMof(out, _u._sint32Array->data(), _u._sint32Array->size);                  set(Array<Sint32>(arraySize));
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 _toMof(out, _u._uint64Array->data(), _u._uint64Array->size);                  set(Array<Uint64>(arraySize));
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 _toMof(out, _u._sint64Array->data(), _u._sint64Array->size);                  set(Array<Sint64>(arraySize));
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 _toMof(out, _u._real32Array->data(), _u._real32Array->size);                  set(Array<Real32>(arraySize));
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 _toMof(out, _u._real64Array->data(), _u._real64Array->size);                  set(Array<Real64>(arraySize));
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 _toMof(out, _u._char16Array->data(), _u._char16Array->size);                  set(Array<Char16>(arraySize));
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 _toMof(out, _u._stringArray->data(), _u._stringArray->size);                  set(Array<String>(arraySize));
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 _toMof(out, _u._dateTimeArray->data(),                  set(Array<CIMDateTime>(arraySize));
                             _u._dateTimeArray->size);  
                 break;                 break;
  
             case CIMType::REFERENCE:              case CIMTYPE_REFERENCE:
                 _toMof(out, _u._referenceArray->data(),                  set(Array<CIMObjectPath>(arraySize));
                             _u._referenceArray->size);                  break;
   
               case CIMTYPE_OBJECT:
                   set(Array<CIMObject>(arraySize));
                 break;                 break;
  
             default:             default:
                 throw CIMValueInvalidType();                  throw TypeMismatchException();
         }         }
     }     }
     else     else
     {     {
         switch (_type)          switch (type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 _toMof(out, Boolean(_u._booleanValue != 0));                  set(false);
                 break;                 break;
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 _toMof(out, _u._uint8Value);                  set(Uint8(0));
                   break;
   
               case CIMTYPE_SINT8:
                   set(Sint8(0));
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_UINT16:
                 _toMof(out, _u._sint8Value);                  set(Uint16(0));
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_SINT16:
                 _toMof(out, _u._uint16Value);                  set(Sint16(0));
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_UINT32:
                 _toMof(out, _u._sint16Value);                  set(Uint32(0));
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_SINT32:
                 _toMof(out, _u._uint32Value);                  set(Sint32(0));
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_UINT64:
                 _toMof(out, _u._sint32Value);                  set(Uint64(0));
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_SINT64:
                 _toMof(out, _u._uint64Value);                  set(Sint64(0));
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_REAL32:
                 _toMof(out, _u._sint64Value);                  set(Real32(0.0));
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL64:
                 _toMof(out, _u._real32Value);                  set(Real64(0.0));
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_CHAR16:
                 _toMof(out, _u._real64Value);                  set(Char16(0));
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_STRING:
                 _toMof(out, Char16(_u._char16Value));                  set(String());
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_DATETIME:
                 _toMof(out, *_u._stringValue);                  set(CIMDateTime());
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_REFERENCE:
                 _toMof(out, *_u._dateTimeValue);                  set(CIMObjectPath());
                 break;                 break;
  
             case CIMType::REFERENCE:              case CIMTYPE_OBJECT:
                 _toMof(out, *_u._referenceValue);                  set(CIMObject());
                 break;                 break;
  
             default:             default:
                 throw CIMValueInvalidType();                  throw TypeMismatchException();
         }  
     }     }
 } }
  
       // Set the Null attribute. Note that this must be after the set
       // because the set functions sets the _isNull.
  
 void CIMValue::print( Boolean forceTag, PEGASUS_STD(ostream) &os) const      _rep->_isNull = true;
 {  
     Array<Sint8> tmp;  
     toXml(tmp, forceTag);  
     tmp.append('\0');  
     os << tmp.getData() << PEGASUS_STD(endl);  
 } }
  
   
 void CIMValue::set(Boolean x) void CIMValue::set(Boolean x)
 { {
     clear();     clear();
     _u._booleanValue = (Uint8)x;      _rep->_u._booleanValue = (Uint8)x;
     _type = CIMType::BOOLEAN;      _rep->_type = CIMTYPE_BOOLEAN;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(Uint8 x) void CIMValue::set(Uint8 x)
 { {
     clear();     clear();
     _u._uint8Value = x;      _rep->_u._uint8Value = x;
     _type = CIMType::UINT8;      _rep->_type = CIMTYPE_UINT8;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(Sint8 x) void CIMValue::set(Sint8 x)
 { {
     clear();     clear();
     _u._sint8Value = x;      _rep->_u._sint8Value = x;
     _type = CIMType::SINT8;      _rep->_type = CIMTYPE_SINT8;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(Uint16 x) void CIMValue::set(Uint16 x)
 { {
     clear();     clear();
     _u._uint16Value = x;      _rep->_u._uint16Value = x;
     _type = CIMType::UINT16;      _rep->_type = CIMTYPE_UINT16;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(Sint16 x) void CIMValue::set(Sint16 x)
 { {
     clear();     clear();
     _u._sint16Value = x;      _rep->_u._sint16Value = x;
     _type = CIMType::SINT16;      _rep->_type = CIMTYPE_SINT16;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(Uint32 x) void CIMValue::set(Uint32 x)
 { {
     clear();     clear();
     _u._uint32Value = x;      _rep->_u._uint32Value = x;
     _type = CIMType::UINT32;      _rep->_type = CIMTYPE_UINT32;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(Sint32 x) void CIMValue::set(Sint32 x)
 { {
     clear();     clear();
     _u._sint32Value = x;      _rep->_u._sint32Value = x;
     _type = CIMType::SINT32;      _rep->_type = CIMTYPE_SINT32;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(Uint64 x) void CIMValue::set(Uint64 x)
 { {
     clear();     clear();
     _u._uint64Value = x;      _rep->_u._uint64Value = x;
     _type = CIMType::UINT64;      _rep->_type = CIMTYPE_UINT64;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(Sint64 x) void CIMValue::set(Sint64 x)
 { {
     clear();     clear();
     _u._sint64Value = x;      _rep->_u._sint64Value = x;
     _type = CIMType::SINT64;      _rep->_type = CIMTYPE_SINT64;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(Real32 x) void CIMValue::set(Real32 x)
 { {
     clear();     clear();
     _u._real32Value = x;      _rep->_u._real32Value = x;
     _type = CIMType::REAL32;      _rep->_type = CIMTYPE_REAL32;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(Real64 x) void CIMValue::set(Real64 x)
 { {
     clear();     clear();
     _u._real64Value = x;      _rep->_u._real64Value = x;
     _type = CIMType::REAL64;      _rep->_type = CIMTYPE_REAL64;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Char16& x) void CIMValue::set(const Char16& x)
 { {
     clear();     clear();
     _u._char16Value = x;      _rep->_u._char16Value = x;
     _type = CIMType::CHAR16;      _rep->_type = CIMTYPE_CHAR16;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const String& x) void CIMValue::set(const String& x)
 { {
     clear();     clear();
     _u._stringValue = new String(x);      _rep->_u._stringValue = new String(x);
     _type = CIMType::STRING;      _rep->_type = CIMTYPE_STRING;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const char* x)  void CIMValue::set(const CIMDateTime& x)
 { {
     set(String(x));      clear();
     _isNull = false;      _rep->_u._dateTimeValue = new CIMDateTime(x);
       _rep->_type = CIMTYPE_DATETIME;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const CIMDateTime& x)  void CIMValue::set(const CIMObjectPath& x)
 { {
     clear();     clear();
     _u._dateTimeValue = new CIMDateTime(x);      _rep->_u._referenceValue = new CIMObjectPath(x);
     _type = CIMType::DATETIME;      _rep->_type = CIMTYPE_REFERENCE;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const CIMReference& x)  void CIMValue::set(const CIMObject& x)
 { {
     clear();     clear();
     _u._referenceValue = new CIMReference(x);      if (x.isUninitialized()) {
     _type = CIMType::REFERENCE;          // Don't need to clone since null CIMObjects aren't shared when created.
     _isNull = false;          // Doesn't work anyway, clone() throws an exception if null.
           _rep->_u._cimobjectValue = new CIMObject(x);
       }
       else {
           _rep->_u._cimobjectValue = new CIMObject(x.clone());
       }
       _rep->_type = CIMTYPE_OBJECT;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Boolean>& x) void CIMValue::set(const Array<Boolean>& x)
 { {
     clear();     clear();
     _Inc(_u._booleanArray = x._rep);      _rep->_u._booleanArray = new Array<Boolean>(x);
     _type = CIMType::BOOLEAN;      _rep->_type = CIMTYPE_BOOLEAN;
     _isArray = true;      _rep->_isArray = true;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Uint8>& x) void CIMValue::set(const Array<Uint8>& x)
 { {
     clear();     clear();
     _Inc(_u._uint8Array = x._rep);      _rep->_u._uint8Array = new Array<Uint8>(x);
     _type = CIMType::UINT8;      _rep->_type = CIMTYPE_UINT8;
     _isArray = true;      _rep->_isArray = true;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Sint8>& x) void CIMValue::set(const Array<Sint8>& x)
 { {
     clear();     clear();
     _Inc(_u._sint8Array = x._rep);      _rep->_u._sint8Array = new Array<Sint8>(x);
     _type = CIMType::SINT8;      _rep->_type = CIMTYPE_SINT8;
     _isArray = true;      _rep->_isArray = true;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Uint16>& x) void CIMValue::set(const Array<Uint16>& x)
 { {
     clear();     clear();
     _Inc(_u._uint16Array = x._rep);      _rep->_u._uint16Array = new Array<Uint16>(x);
     _type = CIMType::UINT16;      _rep->_type = CIMTYPE_UINT16;
     _isArray = true;      _rep->_isArray = true;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Sint16>& x) void CIMValue::set(const Array<Sint16>& x)
 { {
     clear();     clear();
     _Inc(_u._sint16Array = x._rep);      _rep->_u._sint16Array = new Array<Sint16>(x);
     _type = CIMType::SINT16;      _rep->_type = CIMTYPE_SINT16;
     _isArray = true;      _rep->_isArray = true;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Uint32>& x) void CIMValue::set(const Array<Uint32>& x)
 { {
     clear();     clear();
     _Inc(_u._uint32Array = x._rep);      _rep->_u._uint32Array = new Array<Uint32>(x);
     _type = CIMType::UINT32;      _rep->_type = CIMTYPE_UINT32;
     _isArray = true;      _rep->_isArray = true;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Sint32>& x) void CIMValue::set(const Array<Sint32>& x)
 { {
     clear();     clear();
     _Inc(_u._sint32Array = x._rep);      _rep->_u._sint32Array = new Array<Sint32>(x);
     _type = CIMType::SINT32;      _rep->_type = CIMTYPE_SINT32;
     _isArray = true;      _rep->_isArray = true;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Uint64>& x) void CIMValue::set(const Array<Uint64>& x)
 { {
     clear();     clear();
     _Inc(_u._uint64Array = x._rep);      _rep->_u._uint64Array = new Array<Uint64>(x);
     _type = CIMType::UINT64;      _rep->_type = CIMTYPE_UINT64;
     _isArray = true;      _rep->_isArray = true;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Sint64>& x) void CIMValue::set(const Array<Sint64>& x)
 { {
     clear();     clear();
     _Inc(_u._sint64Array = x._rep);      _rep->_u._sint64Array = new Array<Sint64>(x);
     _type = CIMType::SINT64;      _rep->_type = CIMTYPE_SINT64;
     _isArray = true;      _rep->_isArray = true;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Real32>& x) void CIMValue::set(const Array<Real32>& x)
 { {
     clear();     clear();
     _Inc(_u._real32Array = x._rep);      _rep->_u._real32Array = new Array<Real32>(x);
     _type = CIMType::REAL32;      _rep->_type = CIMTYPE_REAL32;
     _isArray = true;      _rep->_isArray = true;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Real64>& x) void CIMValue::set(const Array<Real64>& x)
 { {
     clear();     clear();
     _Inc(_u._real64Array = x._rep);      _rep->_u._real64Array = new Array<Real64>(x);
     _type = CIMType::REAL64;      _rep->_type = CIMTYPE_REAL64;
     _isArray = true;      _rep->_isArray = true;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Char16>& x) void CIMValue::set(const Array<Char16>& x)
 { {
     clear();     clear();
     _Inc(_u._char16Array = x._rep);      _rep->_u._char16Array = new Array<Char16>(x);
     _type = CIMType::CHAR16;      _rep->_type = CIMTYPE_CHAR16;
     _isArray = true;      _rep->_isArray = true;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<String>& x) void CIMValue::set(const Array<String>& x)
 { {
     clear();     clear();
     _Inc(_u._stringArray = x._rep);      _rep->_u._stringArray = new Array<String>(x);
     _type = CIMType::STRING;      _rep->_type = CIMTYPE_STRING;
     _isArray = true;      _rep->_isArray = true;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<CIMDateTime>& x) void CIMValue::set(const Array<CIMDateTime>& x)
 { {
     clear();     clear();
     _Inc(_u._dateTimeArray = x._rep);      _rep->_u._dateTimeArray = new Array<CIMDateTime>(x);
     _type = CIMType::DATETIME;      _rep->_type = CIMTYPE_DATETIME;
     _isArray = true;      _rep->_isArray = true;
     _isNull = false;      _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<CIMReference>& x)  void CIMValue::set(const Array<CIMObjectPath>& x)
 { {
     clear();     clear();
     _Inc(_u._referenceArray = x._rep);      _rep->_u._referenceArray = new Array<CIMObjectPath>(x);
     _type = CIMType::REFERENCE;      _rep->_type = CIMTYPE_REFERENCE;
     _isArray = true;      _rep->_isArray = true;
     _isNull = false;      _rep->_isNull = false;
   }
   
   void CIMValue::set(const Array<CIMObject>& x)
   {
       clear();
       _rep->_u._cimobjectArray = new Array<CIMObject>(x);
       _rep->_type = CIMTYPE_OBJECT;
       _rep->_isArray = true;
       _rep->_isNull = false;
 } }
  
 void CIMValue::get(Boolean& x) const void CIMValue::get(Boolean& x) const
 { {
     if (_type != CIMType::BOOLEAN || _isArray)      if (_rep->_type != CIMTYPE_BOOLEAN || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._booleanValue != 0;      if (!_rep->_isNull)
           x = _rep->_u._booleanValue != 0;
 } }
  
 void CIMValue::get(Uint8& x) const void CIMValue::get(Uint8& x) const
 { {
     if (_type != CIMType::UINT8 || _isArray)      if (_rep->_type != CIMTYPE_UINT8 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._uint8Value;      if (!_rep->_isNull)
           x = _rep->_u._uint8Value;
 } }
  
 void CIMValue::get(Sint8& x) const void CIMValue::get(Sint8& x) const
 { {
     if (_type != CIMType::SINT8 || _isArray)      if (_rep->_type != CIMTYPE_SINT8 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._sint8Value;      if (!_rep->_isNull)
           x = _rep->_u._sint8Value;
 } }
  
 void CIMValue::get(Uint16& x) const void CIMValue::get(Uint16& x) const
 { {
     if (_type != CIMType::UINT16 || _isArray)      if (_rep->_type != CIMTYPE_UINT16 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._uint16Value;      if (!_rep->_isNull)
           x = _rep->_u._uint16Value;
 } }
  
 void CIMValue::get(Sint16& x) const void CIMValue::get(Sint16& x) const
 { {
     if (_type != CIMType::SINT16 || _isArray)      if (_rep->_type != CIMTYPE_SINT16 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._sint16Value;      if (!_rep->_isNull)
           x = _rep->_u._sint16Value;
 } }
  
 void CIMValue::get(Uint32& x) const void CIMValue::get(Uint32& x) const
 { {
     if (_type != CIMType::UINT32 || _isArray)      if (_rep->_type != CIMTYPE_UINT32 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._uint32Value;      if (!_rep->_isNull)
           x = _rep->_u._uint32Value;
 } }
  
 void CIMValue::get(Sint32& x) const void CIMValue::get(Sint32& x) const
 { {
     if (_type != CIMType::SINT32 || _isArray)      if (_rep->_type != CIMTYPE_SINT32 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._sint32Value;      if (!_rep->_isNull)
           x = _rep->_u._sint32Value;
 } }
  
 void CIMValue::get(Uint64& x) const void CIMValue::get(Uint64& x) const
 { {
     if (_type != CIMType::UINT64 || _isArray)      if (_rep->_type != CIMTYPE_UINT64 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._uint64Value;      if (!_rep->_isNull)
           x = _rep->_u._uint64Value;
 } }
  
 void CIMValue::get(Sint64& x) const void CIMValue::get(Sint64& x) const
 { {
     if (_type != CIMType::SINT64 || _isArray)      if (_rep->_type != CIMTYPE_SINT64 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._sint64Value;      if (!_rep->_isNull)
           x = _rep->_u._sint64Value;
 } }
  
 void CIMValue::get(Real32& x) const void CIMValue::get(Real32& x) const
 { {
     if (_type != CIMType::REAL32 || _isArray)      if (_rep->_type != CIMTYPE_REAL32 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._real32Value;      if (!_rep->_isNull)
           x = _rep->_u._real32Value;
 } }
  
 void CIMValue::get(Real64& x) const void CIMValue::get(Real64& x) const
 { {
     if (_type != CIMType::REAL64 || _isArray)      if (_rep->_type != CIMTYPE_REAL64 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._real64Value;      if (!_rep->_isNull)
           x = _rep->_u._real64Value;
 } }
  
 void CIMValue::get(Char16& x) const void CIMValue::get(Char16& x) const
 { {
     if (_type != CIMType::CHAR16 || _isArray)      if (_rep->_type != CIMTYPE_CHAR16 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._char16Value;      if (!_rep->_isNull)
           x = _rep->_u._char16Value;
 } }
  
 void CIMValue::get(String& x) const void CIMValue::get(String& x) const
 { {
     if (_type != CIMType::STRING || _isArray)      if (_rep->_type != CIMTYPE_STRING || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = *_u._stringValue;      if (!_rep->_isNull)
           x = *_rep->_u._stringValue;
 } }
  
 void CIMValue::get(CIMDateTime& x) const void CIMValue::get(CIMDateTime& x) const
 { {
     if (_type != CIMType::DATETIME || _isArray)      if (_rep->_type != CIMTYPE_DATETIME || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
   
       if (!_rep->_isNull)
           x = *_rep->_u._dateTimeValue;
   }
   
   void CIMValue::get(CIMObjectPath& x) const
   {
       if (_rep->_type != CIMTYPE_REFERENCE || _rep->_isArray)
           throw TypeMismatchException();
  
     x = *_u._dateTimeValue;      if (!_rep->_isNull)
           x = *_rep->_u._referenceValue;
 } }
  
 void CIMValue::get(CIMReference& x) const  void CIMValue::get(CIMObject& x) const
 { {
     if (_type != CIMType::REFERENCE || _isArray)      if (_rep->_type != CIMTYPE_OBJECT || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = *_u._referenceValue;      if (!_rep->_isNull)
           x = *_rep->_u._cimobjectValue;
 } }
  
 void CIMValue::get(Array<Boolean>& x) const void CIMValue::get(Array<Boolean>& x) const
 { {
     if (_type != CIMType::BOOLEAN || !_isArray)      if (_rep->_type != CIMTYPE_BOOLEAN || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._booleanArray);      if (!_rep->_isNull)
           x = *_rep->_u._booleanArray;
 } }
  
 void CIMValue::get(Array<Uint8>& x) const void CIMValue::get(Array<Uint8>& x) const
 { {
     if (_type != CIMType::UINT8 || !_isArray)      if (_rep->_type != CIMTYPE_UINT8 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._uint8Array);      if (!_rep->_isNull)
           x = *_rep->_u._uint8Array;
 } }
  
 void CIMValue::get(Array<Sint8>& x) const void CIMValue::get(Array<Sint8>& x) const
 { {
     if (_type != CIMType::SINT8 || !_isArray)      if (_rep->_type != CIMTYPE_SINT8 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._sint8Array);      if (!_rep->_isNull)
           x = *_rep->_u._sint8Array;
 } }
  
 void CIMValue::get(Array<Uint16>& x) const void CIMValue::get(Array<Uint16>& x) const
 { {
     if (_type != CIMType::UINT16 || !_isArray)      if (_rep->_type != CIMTYPE_UINT16 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._uint16Array);      if (!_rep->_isNull)
           x = *_rep->_u._uint16Array;
 } }
  
 void CIMValue::get(Array<Sint16>& x) const void CIMValue::get(Array<Sint16>& x) const
 { {
     if (_type != CIMType::SINT16 || !_isArray)      if (_rep->_type != CIMTYPE_SINT16 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._sint16Array);      if (!_rep->_isNull)
           x = *_rep->_u._sint16Array;
 } }
  
 void CIMValue::get(Array<Uint32>& x) const void CIMValue::get(Array<Uint32>& x) const
 { {
     if (_type != CIMType::UINT32 || !_isArray)      if (_rep->_type != CIMTYPE_UINT32 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._uint32Array);      if (!_rep->_isNull)
           x = *_rep->_u._uint32Array;
 } }
  
 void CIMValue::get(Array<Sint32>& x) const void CIMValue::get(Array<Sint32>& x) const
 { {
     if (_type != CIMType::SINT32 || !_isArray)      if (_rep->_type != CIMTYPE_SINT32 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._sint32Array);      if (!_rep->_isNull)
           x = *_rep->_u._sint32Array;
 } }
  
 void CIMValue::get(Array<Uint64>& x) const void CIMValue::get(Array<Uint64>& x) const
 { {
     if (_type != CIMType::UINT64 || !_isArray)      if (_rep->_type != CIMTYPE_UINT64 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._uint64Array);      if (!_rep->_isNull)
           x = *_rep->_u._uint64Array;
 } }
  
 void CIMValue::get(Array<Sint64>& x) const void CIMValue::get(Array<Sint64>& x) const
 { {
     if (_type != CIMType::SINT64 || !_isArray)      if (_rep->_type != CIMTYPE_SINT64 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._sint64Array);      if (!_rep->_isNull)
           x = *_rep->_u._sint64Array;
 } }
  
 void CIMValue::get(Array<Real32>& x) const void CIMValue::get(Array<Real32>& x) const
 { {
     if (_type != CIMType::REAL32 || !_isArray)      if (_rep->_type != CIMTYPE_REAL32 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._real32Array);      if (!_rep->_isNull)
           x = *_rep->_u._real32Array;
 } }
  
 void CIMValue::get(Array<Real64>& x) const void CIMValue::get(Array<Real64>& x) const
 { {
     if (_type != CIMType::REAL64 || !_isArray)      if (_rep->_type != CIMTYPE_REAL64 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._real64Array);      if (!_rep->_isNull)
           x = *_rep->_u._real64Array;
 } }
  
 void CIMValue::get(Array<Char16>& x) const void CIMValue::get(Array<Char16>& x) const
 { {
     if (_type != CIMType::CHAR16 || !_isArray)      if (_rep->_type != CIMTYPE_CHAR16 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._char16Array);      if (!_rep->_isNull)
           x = *_rep->_u._char16Array;
 } }
  
 void CIMValue::get(Array<String>& x) const void CIMValue::get(Array<String>& x) const
 { {
     if (_type != CIMType::STRING || !_isArray)      if (_rep->_type != CIMTYPE_STRING || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._stringArray);      if (!_rep->_isNull)
           x = *_rep->_u._stringArray;
 } }
  
 void CIMValue::get(Array<CIMDateTime>& x) const void CIMValue::get(Array<CIMDateTime>& x) const
 { {
 #ifdef CIMValueisNullexception      if (_rep->_type != CIMTYPE_DATETIME || !_rep->_isArray)
     if (_isNull)          throw TypeMismatchException();
         throw CIMValueIsNull();  
 #endif  
   
     if (_type != CIMType::DATETIME || !_isArray)  
         throw TypeMismatch();  
  
     x.set(_u._dateTimeArray);      if (!_rep->_isNull)
           x = *_rep->_u._dateTimeArray;
 } }
  
 void CIMValue::get(Array<CIMReference>& x) const  void CIMValue::get(Array<CIMObjectPath>& x) const
 { {
     if (_type != CIMType::REFERENCE || !_isArray)      if (_rep->_type != CIMTYPE_REFERENCE || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._referenceArray);      if (!_rep->_isNull)
           x = *_rep->_u._referenceArray;
 } }
  
 void CIMValue::_init()  void CIMValue::get(Array<CIMObject>& x) const
 { {
     _type = CIMType::NONE;      if (_rep->_type != CIMTYPE_OBJECT || !_rep->_isArray)
     _isArray = false;          throw TypeMismatchException();
     _isNull = true;  
     _u._voidPtr = 0;      if (!_rep->_isNull)
           x = *_rep->_u._cimobjectArray;
 } }
  
 Boolean operator==(const CIMValue& x, const CIMValue& y)  Boolean CIMValue::equal(const CIMValue& x) const
 { {
     if (!x.typeCompatible(y))      if (!typeCompatible(x))
         return false;         return false;
  
     if (x._isNull != y._isNull)      if (_rep->_isNull != x._rep->_isNull)
         return false;         return false;
  
     if (x._isArray)      if (_rep->_isArray)
     {     {
         switch (x._type)          switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 return Array<Boolean>(x._u._booleanArray) ==                  return (*_rep->_u._booleanArray) ==
                     Array<Boolean>(y._u._booleanArray);                      (*x._rep->_u._booleanArray);
   
             case CIMType::UINT8:  
                 return Array<Uint8>(x._u._uint8Array) ==  
                     Array<Uint8>(y._u._uint8Array);  
   
             case CIMType::SINT8:  
                 return Array<Sint8>(x._u._sint8Array) ==  
                     Array<Sint8>(y._u._sint8Array);  
   
             case CIMType::UINT16:  
                 return Array<Uint16>(x._u._uint16Array) ==  
                     Array<Uint16>(y._u._uint16Array);  
  
             case CIMType::SINT16:              case CIMTYPE_UINT8:
                 return Array<Sint16>(x._u._sint16Array) ==                  return (*_rep->_u._uint8Array) ==
                     Array<Sint16>(y._u._sint16Array);                      (*x._rep->_u._uint8Array);
  
             case CIMType::UINT32:              case CIMTYPE_SINT8:
                 return Array<Uint32>(x._u._uint32Array) ==                  return (*_rep->_u._sint8Array) ==
                     Array<Uint32>(y._u._uint32Array);                      (*x._rep->_u._sint8Array);
  
             case CIMType::SINT32:              case CIMTYPE_UINT16:
                 return Array<Sint32>(x._u._sint32Array) ==                  return (*_rep->_u._uint16Array) ==
                     Array<Sint32>(y._u._sint32Array);                      (*x._rep->_u._uint16Array);
   
             case CIMType::UINT64:  
                 return Array<Uint64>(x._u._uint64Array) ==  
                     Array<Uint64>(y._u._uint64Array);  
   
             case CIMType::SINT64:  
                 return Array<Sint64>(x._u._sint64Array) ==  
                     Array<Sint64>(y._u._sint64Array);  
   
             case CIMType::REAL32:  
                 return Array<Real32>(x._u._real32Array) ==  
                     Array<Real32>(y._u._real32Array);  
   
             case CIMType::REAL64:  
                 return Array<Real64>(x._u._real64Array) ==  
                     Array<Real64>(y._u._real64Array);  
   
             case CIMType::CHAR16:  
                 return Array<Char16>(x._u._char16Array) ==  
                     Array<Char16>(y._u._char16Array);  
   
             case CIMType::STRING:  
                 return Array<String>(x._u._stringArray) ==  
                     Array<String>(y._u._stringArray);  
   
             case CIMType::DATETIME:  
                 return Array<CIMDateTime>(x._u._dateTimeArray) ==  
                     Array<CIMDateTime>(y._u._dateTimeArray);  
   
             case CIMType::REFERENCE:  
                 return Array<CIMReference>(x._u._referenceArray) ==  
                     Array<CIMReference>(y._u._referenceArray);  
             default:  
                 throw CIMValueInvalidType();  
         }  
     }  
     else  
     {  
         switch (x._type)  
         {  
             case CIMType::BOOLEAN:  
                 return x._u._booleanValue == y._u._booleanValue;  
  
             case CIMType::UINT8:              case CIMTYPE_SINT16:
                 return x._u._uint8Value == y._u._uint8Value;                  return (*_rep->_u._sint16Array) ==
                       (*x._rep->_u._sint16Array);
  
             case CIMType::SINT8:              case CIMTYPE_UINT32:
                 return x._u._sint8Value == y._u._sint8Value;                  return (*_rep->_u._uint32Array) ==
                       (*x._rep->_u._uint32Array);
  
             case CIMType::UINT16:              case CIMTYPE_SINT32:
                 return x._u._uint16Value == y._u._uint16Value;                  return (*_rep->_u._sint32Array) ==
                       (*x._rep->_u._sint32Array);
  
             case CIMType::SINT16:              case CIMTYPE_UINT64:
                 return x._u._sint16Value == y._u._sint16Value;                  return (*_rep->_u._uint64Array) ==
                       (*x._rep->_u._uint64Array);
  
             case CIMType::UINT32:              case CIMTYPE_SINT64:
                 return x._u._uint32Value == y._u._uint32Value;                  return (*_rep->_u._sint64Array) ==
                       (*x._rep->_u._sint64Array);
  
             case CIMType::SINT32:              case CIMTYPE_REAL32:
                 return x._u._sint32Value == y._u._sint32Value;                  return (*_rep->_u._real32Array) ==
                       (*x._rep->_u._real32Array);
  
             case CIMType::UINT64:              case CIMTYPE_REAL64:
                 return x._u._uint64Value == y._u._uint64Value;                  return (*_rep->_u._real64Array) ==
                       (*x._rep->_u._real64Array);
  
             case CIMType::SINT64:              case CIMTYPE_CHAR16:
                 return x._u._sint64Value == y._u._sint64Value;                  return (*_rep->_u._char16Array) ==
                       (*x._rep->_u._char16Array);
  
             case CIMType::REAL32:              case CIMTYPE_STRING:
                 return x._u._real32Value == y._u._real32Value;                  return (*_rep->_u._stringArray) ==
                       (*x._rep->_u._stringArray);
  
             case CIMType::REAL64:              case CIMTYPE_DATETIME:
                 return x._u._real64Value == y._u._real64Value;                  return (*_rep->_u._dateTimeArray) ==
                       (*x._rep->_u._dateTimeArray);
  
             case CIMType::CHAR16:              case CIMTYPE_REFERENCE:
                 return x._u._char16Value == y._u._char16Value;                  return (*_rep->_u._referenceArray) ==
                       (*x._rep->_u._referenceArray);
  
             case CIMType::STRING:              case CIMTYPE_OBJECT:
                 return String::equal(*x._u._stringValue, *y._u._stringValue);                  return (*_rep->_u._cimobjectArray) ==
                       (*x._rep->_u._cimobjectArray);
  
             case CIMType::DATETIME:  
                 return *x._u._dateTimeValue == *y._u._dateTimeValue;  
   
             case CIMType::REFERENCE:  
                 return *x._u._referenceValue == *y._u._referenceValue;  
             default:             default:
                 throw CIMValueInvalidType();                  PEGASUS_ASSERT(false);
         }         }
     }     }
       else
     // Unreachable!  
     return false;  
 }  
   
 void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize)  
 {  
   
     clear();  
   
     if (isArray)  
     {     {
         switch (type)          switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 set(Array<Boolean>(arraySize));                  return _rep->_u._booleanValue == x._rep->_u._booleanValue;
                 break;  
   
             case CIMType::UINT8:  
                 set(Array<Uint8>(arraySize));  
                 break;  
   
             case CIMType::SINT8:  
                 set(Array<Sint8>(arraySize));  
                 break;  
   
             case CIMType::UINT16:  
                 set(Array<Uint16>(arraySize));  
                 break;  
   
             case CIMType::SINT16:  
                 set(Array<Sint16>(arraySize));  
                 break;  
   
             case CIMType::UINT32:  
                 set(Array<Uint32>(arraySize));  
                 break;  
   
             case CIMType::SINT32:  
                 set(Array<Sint32>(arraySize));  
                 break;  
   
             case CIMType::UINT64:  
                 set(Array<Uint64>(arraySize));  
                 break;  
   
             case CIMType::SINT64:  
                 set(Array<Sint64>(arraySize));  
                 break;  
   
             case CIMType::REAL32:  
                 set(Array<Real32>(arraySize));  
                 break;  
   
             case CIMType::REAL64:  
                 set(Array<Real64>(arraySize));  
                 break;  
   
             case CIMType::CHAR16:  
                 set(Array<Char16>(arraySize));  
                 break;  
  
             case CIMType::STRING:              case CIMTYPE_UINT8:
                 set(Array<String>(arraySize));                  return _rep->_u._uint8Value == x._rep->_u._uint8Value;
                 break;  
  
             case CIMType::DATETIME:              case CIMTYPE_SINT8:
                 set(Array<CIMDateTime>(arraySize));                  return _rep->_u._sint8Value == x._rep->_u._sint8Value;
                 break;  
   
             case CIMType::REFERENCE:  
                 set(Array<CIMReference>(arraySize));  
                 break;  
             default:  
                 throw CIMValueInvalidType();  
         }  
     }  
     else  
     {  
         switch (type)  
         {  
             case CIMType::BOOLEAN:  
                 set(false);  
                 break;  
  
             case CIMType::UINT8:              case CIMTYPE_UINT16:
                 set(Uint8(0));                  return _rep->_u._uint16Value == x._rep->_u._uint16Value;
                 break;  
  
             case CIMType::SINT8:              case CIMTYPE_SINT16:
                 set(Sint8(0));                  return _rep->_u._sint16Value == x._rep->_u._sint16Value;
                 break;  
  
             case CIMType::UINT16:              case CIMTYPE_UINT32:
                 set(Uint16(0));                  return _rep->_u._uint32Value == x._rep->_u._uint32Value;
                 break;  
  
             case CIMType::SINT16:              case CIMTYPE_SINT32:
                 set(Sint16(0));                  return _rep->_u._sint32Value == x._rep->_u._sint32Value;
                 break;  
  
             case CIMType::UINT32:              case CIMTYPE_UINT64:
                 set(Uint32(0));                  return _rep->_u._uint64Value == x._rep->_u._uint64Value;
                 break;  
  
             case CIMType::SINT32:              case CIMTYPE_SINT64:
                 set(Sint32(0));                  return _rep->_u._sint64Value == x._rep->_u._sint64Value;
                 break;  
  
             case CIMType::UINT64:              case CIMTYPE_REAL32:
                 set(Uint64(0));                  return _rep->_u._real32Value == x._rep->_u._real32Value;
                 break;  
  
             case CIMType::SINT64:              case CIMTYPE_REAL64:
                 set(Sint64(0));                  return _rep->_u._real64Value == x._rep->_u._real64Value;
                 break;  
  
             case CIMType::REAL32:              case CIMTYPE_CHAR16:
                 set(Real32(0.0));                  return _rep->_u._char16Value == x._rep->_u._char16Value;
                 break;  
  
             case CIMType::REAL64:              case CIMTYPE_STRING:
                 set(Real64(0.0));                  return String::equal(*_rep->_u._stringValue,
                 break;                                       *x._rep->_u._stringValue);
  
             case CIMType::CHAR16:              case CIMTYPE_DATETIME:
                 set(Char16(0));                  return *_rep->_u._dateTimeValue == *x._rep->_u._dateTimeValue;
                 break;  
  
             case CIMType::STRING:              case CIMTYPE_REFERENCE:
                 set(String());                  return *_rep->_u._referenceValue ==
                 break;                      *x._rep->_u._referenceValue;
  
             case CIMType::DATETIME:              case CIMTYPE_OBJECT:
                 set(CIMDateTime());                  return (*_rep->_u._cimobjectValue).identical((*x._rep->_u._cimobjectValue));
                 break;  
  
             case CIMType::REFERENCE:  
                 set(CIMReference());  
                 break;  
             default:             default:
                 throw CIMValueInvalidType();                  PEGASUS_ASSERT(false);
         }         }
     }     }
  
     // Set the Null attribute. Note that this must be after the set      // Unreachable!
     // because the set functions sets the _isNull.      return false;
   
     _isNull = true;  
 } }
  
 String CIMValue::toString() const String CIMValue::toString() const
Line 1949 
Line 1622 
  
     //ATTN: Not sure what we should do with getstring for Null CIMValues     //ATTN: Not sure what we should do with getstring for Null CIMValues
     //Choice return empty string or exception out.     //Choice return empty string or exception out.
     if (_isNull)      if (_rep->_isNull)
         return String();         return String();
  
     if (_isArray)      if (_rep->_isArray)
     {     {
         switch (_type)          switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
             {             {
                 int size = _u._booleanArray->size;                  Uint32 size = _rep->_u._booleanArray->size();
                 bool *p = _u._booleanArray->data();                  for (Uint32 i = 0; i < size; i++)
                 for (Uint32 i = 0; i < _u._booleanArray->size; i++)  
                 {                 {
                     _toString(out, Boolean(_u._booleanArray->data()[i]));                      _toString(out, Boolean(_rep->_u._booleanArray->getData()[i]));
                     out << " ";                     out << " ";
                 }                 }
                 break;                 break;
             }             }
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 _toString(out, _u._uint8Array->data(), _u._uint8Array->size);                  _toString(out, _rep->_u._uint8Array->getData(),
                                  _rep->_u._uint8Array->size());
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 _toString(out, _u._sint8Array->data(), _u._sint8Array->size);                  _toString(out, _rep->_u._sint8Array->getData(),
                                  _rep->_u._sint8Array->size());
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 _toString(out, _u._uint16Array->data(), _u._uint16Array->size);                  _toString(out, _rep->_u._uint16Array->getData(),
                                  _rep->_u._uint16Array->size());
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 _toString(out, _u._sint16Array->data(), _u._sint16Array->size);                  _toString(out, _rep->_u._sint16Array->getData(),
                                  _rep->_u._sint16Array->size());
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 _toString(out, _u._uint32Array->data(), _u._uint32Array->size);                  _toString(out, _rep->_u._uint32Array->getData(),
                                  _rep->_u._uint32Array->size());
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 _toString(out, _u._sint32Array->data(), _u._sint32Array->size);                  _toString(out, _rep->_u._sint32Array->getData(),
                                  _rep->_u._sint32Array->size());
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 _toString(out, _u._uint64Array->data(), _u._uint64Array->size);                  _toString(out, _rep->_u._uint64Array->getData(),
                                  _rep->_u._uint64Array->size());
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 _toString(out, _u._sint64Array->data(), _u._sint64Array->size);                  _toString(out, _rep->_u._sint64Array->getData(),
                                  _rep->_u._sint64Array->size());
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 _toString(out, _u._real32Array->data(), _u._real32Array->size);                  _toString(out, _rep->_u._real32Array->getData(),
                                  _rep->_u._real32Array->size());
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 _toString(out, _u._real64Array->data(), _u._real64Array->size);                  _toString(out, _rep->_u._real64Array->getData(),
                                  _rep->_u._real64Array->size());
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 _toString(out, _u._char16Array->data(), _u._char16Array->size);                  _toString(out, _rep->_u._char16Array->getData(),
                                  _rep->_u._char16Array->size());
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 _toString(out, _u._stringArray->data(), _u._stringArray->size);                  _toString(out, _rep->_u._stringArray->getData(),
                                  _rep->_u._stringArray->size());
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 _toString(out, _u._dateTimeArray->data(), _u._dateTimeArray->size);                  _toString(out, _rep->_u._dateTimeArray->getData(),
                                  _rep->_u._dateTimeArray->size());
                 break;                 break;
  
             case CIMType::REFERENCE:              case CIMTYPE_REFERENCE:
                 _toString(out, _u._referenceArray->data(), _u._referenceArray->size);                  _toString(out, _rep->_u._referenceArray->getData(),
                                  _rep->_u._referenceArray->size());
                   break;
   
               case CIMTYPE_OBJECT:
                   _toString(out, _rep->_u._cimobjectArray->getData(),
                                  _rep->_u._cimobjectArray->size());
                 break;                 break;
  
             default:             default:
                 throw CIMValueInvalidType();                  PEGASUS_ASSERT(false);
         }         }
     }     }
     else     else
     {     {
         switch (_type)          switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 _toString(out, Boolean(_u._booleanValue != 0));                  _toString(out, Boolean(_rep->_u._booleanValue != 0));
                 break;                 break;
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 _toString(out, _u._uint8Value);                  _toString(out, _rep->_u._uint8Value);
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 _toString(out, _u._sint8Value);                  _toString(out, _rep->_u._sint8Value);
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 _toString(out, _u._uint16Value);                  _toString(out, _rep->_u._uint16Value);
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 _toString(out, _u._sint16Value);                  _toString(out, _rep->_u._sint16Value);
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 _toString(out, _u._uint32Value);                  _toString(out, _rep->_u._uint32Value);
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 _toString(out, _u._sint32Value);                  _toString(out, _rep->_u._sint32Value);
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 _toString(out, _u._uint64Value);                  _toString(out, _rep->_u._uint64Value);
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 _toString(out, _u._sint64Value);                  _toString(out, _rep->_u._sint64Value);
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 _toString(out, _u._real32Value);                  _toString(out, _rep->_u._real32Value);
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 _toString(out, _u._real64Value);                  _toString(out, _rep->_u._real64Value);
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 _toString(out, Char16(_u._char16Value));                  _toString(out, Char16(_rep->_u._char16Value));
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 _toString(out, *_u._stringValue);                  _toString(out, *_rep->_u._stringValue);
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 _toString(out, *_u._dateTimeValue);                  _toString(out, *_rep->_u._dateTimeValue);
                 break;                 break;
  
             case CIMType::REFERENCE:              case CIMTYPE_REFERENCE:
                 _toString(out, *_u._referenceValue);                  _toString(out, *_rep->_u._referenceValue);
                   break;
   
               case CIMTYPE_OBJECT:
                   _toString(out, *_rep->_u._cimobjectValue);
                 break;                 break;
  
             default:             default:
                 throw CIMValueInvalidType();                  PEGASUS_ASSERT(false);
         }         }
     }     }
  
Line 2101 
Line 1796 
     return out.getData();     return out.getData();
 } }
  
   
   Boolean operator==(const CIMValue& x, const CIMValue& y)
   {
       return x.equal(y);
   }
   
   Boolean operator!=(const CIMValue& x, const CIMValue& y)
   {
       return !x.equal(y);
   }
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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