(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.67

version 1.24, 2002/04/01 19:06:03 version 1.67, 2006/05/02 20:26:59
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // 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.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec 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 33 
 // //
 // 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
   //              Dave Sudlik, IBM (dsudlik@us.ibm.com)
   //              David Dillard, VERITAS Software Corp.
   //                  (david.dillard@veritas.com)
   //              Mike Brasher, Inova Europe (mike-brasher@austin.rr.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <cstring> #include <cstring>
 #include <cstdio> #include <cstdio>
 #include <cassert>  
 #include <cctype> #include <cctype>
 #include "CIMValue.h" #include "CIMValue.h"
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
   #include "CIMInstance.h"
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
   #include "Union.h"
 #include "Indentor.h" #include "Indentor.h"
 #include "Exception.h"  
 #include "XmlWriter.h" #include "XmlWriter.h"
   #include "CommonUTF.h"
   #include "CIMValueRep.h"
   #include "Config.h"
   #include "CIMType.h"
   #include "String.h"
   #include "CIMDateTime.h"
   #include "CIMObjectPath.h"
   #include "CIMObject.h"
   #include "Array.h"
   #include <Pegasus/Common/PegasusAssert.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 42 
Line 70 
 # include "ArrayImpl.h" # include "ArrayImpl.h"
 #undef PEGASUS_ARRAY_T #undef PEGASUS_ARRAY_T
  
 template<class T>  // ATTN: By getting a CIMObject from a CIMValue, the client of CIMValue can
 inline void _Inc(ArrayRep<T>* rep)  // modify the internals of that CIMObject and thus change what CIMValue
 {  // itself refers to. There are two solutions: clone() at ever juncture or
     ArrayRep<T>::inc(rep);  // force CIMValue to make its own unique copy when the client calls get()
 }  // to get a CIMObject.
   
 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()  
 //  
 //------------------------------------------------------------------------------  
   
 static void _SignedIntToStr(Sint64 x, char* result)  
 {  
     if (!result)  
         return;  
   
     if (x == 0)  
     {  
         result[0] = '0';  
         result[1] = '\0';  
         return;  
     }  
   
     char buffer[32];  
     Uint32 len = 0;  
     Boolean negative = false;  
  
     while (x)  //==============================================================================
     {  
         Sint32 r = x % 10;  
         x = x / 10;  
   
         if (r < 0)  
         {  
             r = -r;  
             negative = true;  
         }  
   
         buffer[len++] = r + '0';  
     }  
   
     buffer[len] = '\0';  
   
     // If buffer was negative, prepend sign:  
   
     char* q = result;  
   
     if (negative)  
         *q++ = '-';  
   
     // Reverse the buffer:  
   
     char* p = &buffer[len];  
   
     while (len--)  
         *q++ = *--p;  
   
     *q++ = '\0';  
 }  
   
 //------------------------------------------------------------------------------  
 // //
 // _UnsignedIntToStr()  // _toString() routines:
 // //
 //------------------------------------------------------------------------------  //==============================================================================
   
 static void _UnsignedIntToStr(Uint64 x, char* result)  
 {  
     if (!result)  
         return;  
  
     if (x == 0)  inline void _toString(Buffer& out, Boolean x)
     {     {
         result[0] = '0';      XmlWriter::append(out, x);
         result[1] = '\0';  
         return;  
     }     }
  
     char buffer[32];  inline void _toString(Buffer& out, Uint8 x)
     Uint32 len = 0;  
   
     while (x)  
     {     {
         Uint32 r = x % 10;      XmlWriter::append(out, Uint32(x));
         x = x / 10;  
   
         buffer[len++] = r + '0';  
     }  
   
     buffer[len] = '\0';  
   
     // Reverse the buffer onto output:  
   
     char* q = result;  
   
     char* p = &buffer[len];  
   
     while (len--)  
         *q++ = *--p;  
   
     *q++ = '\0';  
 } }
 #endif  
  
 //------------------------------------------------------------------------------  inline void _toString(Buffer& out, Sint8 x)
 //  
 // _toString, _toXml(), and _toMof routines:  
 //  
 //------------------------------------------------------------------------------  
   
 inline void _toString(Array<Sint8>& out, Boolean x)  
 { {
     out << (x ? "TRUE" : "FALSE");      XmlWriter::append(out, Sint32(x));
 } }
  
 inline void _toXml(Array<Sint8>& out, Boolean x) { _toString(out, x); }  inline void _toString(Buffer& out, Uint16 x)
 inline void _toMof(Array<Sint8>& out, Boolean x) { _toString(out, x); }  
   
 inline void _integerToString(Array<Sint8>& out, Sint32 x)  
 { {
     char buffer[32];      XmlWriter::append(out, Uint32(x));
     sprintf(buffer, "%d", x);  
     out << (char*)buffer;  
 } }
  
 inline void _unsignedIntegerToString(Array<Sint8>& out, Uint32 x)  inline void _toString(Buffer& out, Sint16 x)
 { {
     char buffer[32];      XmlWriter::append(out, Sint32(x));
     sprintf(buffer, "%u", x);  
     out << (char*)buffer;  
 } }
  
 inline void _toString(Array<Sint8>& out, Uint8 x) { _unsignedIntegerToString(out, x); }  inline void _toString(Buffer& out, Uint32 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      XmlWriter::append(out, x);
     // I know I shouldn't put platform flags here, but the other was is too hard  
 #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)  
     sprintf(buffer, "%I64u", x);  
 #else  
     sprintf(buffer, "%llu", x);  
 #endif  
     out << buffer;  
 } }
  
 inline void _toXml(Array<Sint8>& out, Uint64 x) { _toString(out, x); }  inline void _toString(Buffer& out, Sint32 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      XmlWriter::append(out, x);
     // I know I shouldn't put platform flags here, but the other was is too hard  
 #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)  
     sprintf(buffer, "%I64d", x);  
 #else  
     sprintf(buffer, "%lld", x);  
 #endif  
     out << buffer;  
 } }
  
 inline void _toXml(Array<Sint8>& out, Sint64 x) { _toString(out, x); }  inline void _toString(Buffer& out, Uint64 x)
 inline void _toMof(Array<Sint8>& out, Sint64 x) { _toString(out, x); }  
   
 void _toString(Array<Sint8>& out, Real64 x)  
 { {
     char buffer[128];      XmlWriter::append(out, x);
     // %e gives '[-]m.dddddde+/-xx', which seems compatible with CIM/XML spec  
     sprintf(buffer, "%e", x);  
     out << buffer;  
 } }
  
 inline void _toXml(Array<Sint8>& out, Real64 x) { _toString(out, x); }  inline void _toString(Buffer& out, Sint64 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?  
     out.append(Sint8(x));  
 }  
 inline void _toXml(Array<Sint8>& out, Char16 x)  
 {  
     XmlWriter::appendSpecial(out, x);  
 }  
 inline void _toMof(Array<Sint8>& out, Char16 x)  
 { {
     XmlWriter::appendSpecial(out, x);      XmlWriter::append(out, x);
 } }
  
 inline void _toString(Array<Sint8>& out, const String& x)  inline void _toString(Buffer& out, Real32 x)
 { {
     out << x;      XmlWriter::append(out, Real64(x));
 } }
  
 inline void _toXml(Array<Sint8>& out, const String& x)  inline void _toString(Buffer& out, Real64 x)
 { {
     XmlWriter::appendSpecial(out, x);      XmlWriter::append(out, x);
 } }
  
 /** _toMof Internal function to convert the string back  inline void _toString(Buffer& out, Char16 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)      // We need to convert the Char16 to UTF8 then append the UTF8
         {      // character into the array.
         case '\\':      // NOTE: The UTF8 character could be several bytes long.
                 out.append("\\\\",2);      // WARNING: This function will put in replacement character for
                 break;      // all characters that have surogate pairs.
  
             case '\b':      char str[6];
                 out.append("\\b",2);      memset(str,0x00,sizeof(str));
                 break;      char* charIN = (char *)&x;
  
             case '\t':      const Uint16 *strsrc = (Uint16 *)charIN;
                 out.append("\\t",2);      Uint16 *endsrc = (Uint16 *)&charIN[1];
                 break;  
  
             case '\n':      Uint8 *strtgt = (Uint8 *)str;
                 out.append("\\n",2);      Uint8 *endtgt = (Uint8 *)&str[5];
                 break;  
   
             case '\f':  
                 out.append("\\f",2);  
                 break;  
   
             case '\r':  
                 out.append("\\r",2);  
                 break;  
  
            /* case '\'':      UTF16toUTF8(&strsrc, endsrc, &strtgt, endtgt);
                 out.append("\\'", 2);      out.append(str, UTF_8_COUNT_TRAIL_BYTES(str[0]) +1);
                 break;*/  
   
             case '"':  
                 out.append("\\\"", 2);  
                 break;  
   
             default:  
                 out.append(Sint8(c));  
         }  
   
     }  
     out << "\"";  
 } }
  
 inline void _toString(Array<Sint8>& out, const CIMDateTime& x)  inline void _toString(Buffer& out, const String& x)
 { {
     out << x.getString();      out << x;
 } }
  
 inline void _toXml(Array<Sint8>& out, const CIMDateTime& x) { _toString(out, x); }  inline void _toString(Buffer& out, const CIMDateTime& x)
 inline void _toMof(Array<Sint8>& out, const CIMDateTime& x) { _toString(out, x); }  
   
 inline void _toString(Array<Sint8>& out, const CIMReference& x)  
 { {
     out << x.toString();     out << x.toString();
 } }
 inline void _toXml(Array<Sint8>& out, const CIMReference& x)  
 {  
     x.toXml(out);  
 }  
 inline void _toMof(Array<Sint8>& out, const CIMReference& x)  
 {  
     x.toMof(out);  
 }  
  
 template<class T>  inline void _toString(Buffer& out, const CIMObjectPath& x)
 void _toString(Array<Sint8>& out, const T* p, Uint32 size)  
 {  
     while (size--)  
     {     {
         _toString(out, *p++);      out << x.toString();
         out << " ";  
     }  
 } }
  
 void _toXml(Array<Sint8>& out, const CIMReference* p, Uint32 size)  inline void _toString(Buffer& out, const CIMObject& x)
 { {
     out << "<VALUE.REFARRAY>\n";      out << x.toString();
     while (size--)  
     {  
         _toXml(out, *p++);  
     }  
     out << "</VALUE.REFARRAY>\n";  
 } }
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
 template<class T>  inline void _toString(Buffer& out, const CIMInstance& x)
 void _toXml(Array<Sint8>& out, const T* p, Uint32 size)  
 { {
     out << "<VALUE.ARRAY>\n";      out << CIMObject(x).toString();
   
     while (size--)  
     {  
         out << "<VALUE>";  
   
         _toXml(out, *p++);  
   
         out << "</VALUE>\n";  
     }     }
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
  
     out << "</VALUE.ARRAY>\n";  
 }  
 /** _toMof Array -  
     arrayInitializer  = "{" constantValue*( "," constantValue)"}"  
   
 */  
 template<class T> template<class T>
 void _toMof(Array<Sint8>& out, const T* p, Uint32 size)  void _toString(Buffer& out, const T* p, Uint32 size)
 {  
     Boolean isFirstEntry = true;  
     // if there are any entries in the array output them  
     if (size)  
     {     {
         out << "{";  
         while (size--)         while (size--)
         {         {
             // Put comma on all but first entry.          _toString(out, *p++);
             if (!isFirstEntry)          out.append(' ');
             {  
                 out << ", ";  
             }  
             isFirstEntry = false;  
             _toMof(out, *p++);  
         }  
         out << "}";  
   
     }     }
 } }
  
 ////////////////////////////////////////////////////////////////////////////////  //==============================================================================
 // //
 // CIMValue  // CIMValueRep
 // //
 ////////////////////////////////////////////////////////////////////////////////  //==============================================================================
   
 CIMValue::CIMValue()  
 {  
     _init();  
 }  
  
 CIMValue::CIMValue(CIMType type, Boolean isArray, Uint32 arraySize)  CIMValueRep CIMValueRep::_emptyRep((int*)0);
 {  
     _init();  
     setNullValue(type, isArray, arraySize);  
 }  
  
 CIMValue::CIMValue(const CIMValue& x)  void CIMValueRep::release()
 { {
     _init();      if (isArray)
     assign(x);  
 }  
   
 CIMValue::~CIMValue()  
 { {
     clear();          switch (type)
 }  
   
 void CIMValue::assign(const CIMValue& x)  
 { {
     if (this == &x)              case CIMTYPE_BOOLEAN:
         return;                  CIMValueType<Boolean>::destructArray(this);
                   break;
     clear();  
   
     _type = x._type;  
     _isArray = x._isArray;  
     _isNull = x._isNull;  
     _u._voidPtr = 0;  
  
     if (_isArray)              case CIMTYPE_UINT8:
     {                  CIMValueType<Uint8>::destructArray(this);
         switch (_type)  
         {  
             case CIMType::BOOLEAN:  
                 _Inc(_u._booleanArray = x._u._booleanArray);  
                 break;                 break;
  
             case CIMType::UINT8:              case CIMTYPE_SINT8:
                 _Inc(_u._uint8Array = x._u._uint8Array);                  CIMValueType<Sint8>::destructArray(this);
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_UINT16:
                 _Inc(_u._sint8Array = x._u._sint8Array);                  CIMValueType<Uint16>::destructArray(this);
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_SINT16:
                 _Inc(_u._uint16Array = x._u._uint16Array);                  CIMValueType<Sint16>::destructArray(this);
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_UINT32:
                 _Inc(_u._sint16Array = x._u._sint16Array);                  CIMValueType<Uint32>::destructArray(this);
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_SINT32:
                 _Inc(_u._uint32Array = x._u._uint32Array);                  CIMValueType<Sint32>::destructArray(this);
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_UINT64:
                 _Inc(_u._sint32Array = x._u._sint32Array);                  CIMValueType<Uint64>::destructArray(this);
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_SINT64:
                 _Inc(_u._uint64Array = x._u._uint64Array);                  CIMValueType<Sint64>::destructArray(this);
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_REAL32:
                 _Inc(_u._sint64Array = x._u._sint64Array);                  CIMValueType<Real32>::destructArray(this);
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL64:
                 _Inc(_u._real32Array = x._u._real32Array);                  CIMValueType<Real64>::destructArray(this);
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_CHAR16:
                 _Inc(_u._real64Array = x._u._real64Array);                  CIMValueType<Char16>::destructArray(this);
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_STRING:
                 _Inc(_u._char16Array = x._u._char16Array);                  CIMValueType<String>::destructArray(this);
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_DATETIME:
                 _Inc(_u._stringArray = x._u._stringArray);                  CIMValueType<CIMDateTime>::destructArray(this);
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_REFERENCE:
                 _Inc(_u._dateTimeArray = x._u._dateTimeArray);                  CIMValueType<CIMObjectPath>::destructArray(this);
                 break;                 break;
  
             case CIMType::REFERENCE:              case CIMTYPE_OBJECT:
                 _Inc(_u._referenceArray = x._u._referenceArray);                  CIMValueType<CIMObject>::destructArray(this);
                 break;                 break;
             default:  #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
                 throw CIMValueInvalidType();              case CIMTYPE_INSTANCE:
                   CIMValueType<CIMInstance>::destructArray(this);
                   break;
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
         }         }
     }     }
     else     else
     {     {
         switch (_type)          switch (type)
         {         {
             case CIMType::NONE:              case CIMTYPE_BOOLEAN:
                 break;              case CIMTYPE_UINT8:
               case CIMTYPE_SINT8:
             case CIMType::BOOLEAN:              case CIMTYPE_UINT16:
                 _u._booleanValue = x._u._booleanValue;              case CIMTYPE_SINT16:
                 break;              case CIMTYPE_UINT32:
               case CIMTYPE_SINT32:
             case CIMType::UINT8:              case CIMTYPE_UINT64:
                 _u._uint8Value = x._u._uint8Value;              case CIMTYPE_SINT64:
                 break;              case CIMTYPE_REAL32:
               case CIMTYPE_REAL64:
             case CIMType::SINT8:              case CIMTYPE_CHAR16:
                 _u._sint8Value = x._u._sint8Value;  
                 break;  
   
             case CIMType::UINT16:  
                 _u._uint16Value = x._u._uint16Value;  
                 break;  
   
             case CIMType::SINT16:  
                 _u._sint16Value = x._u._sint16Value;  
                 break;  
   
             case CIMType::UINT32:  
                 _u._uint32Value = x._u._uint32Value;  
                 break;  
   
             case CIMType::SINT32:  
                 _u._sint32Value = x._u._sint32Value;  
                 break;  
   
             case CIMType::UINT64:  
                 _u._uint64Value = x._u._uint64Value;  
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_STRING:
                 _u._sint64Value = x._u._sint64Value;                  CIMValueType<String>::destruct(this);
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_DATETIME:
                 _u._real32Value = x._u._real32Value;                  CIMValueType<CIMDateTime>::destruct(this);
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_REFERENCE:
                 _u._real64Value = x._u._real64Value;                  CIMValueType<CIMObjectPath>::destruct(this);
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_OBJECT:
                 _u._char16Value = x._u._char16Value;                  CIMValueType<CIMObject>::destruct(this);
                 break;                 break;
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
             case CIMType::STRING:              case CIMTYPE_INSTANCE:
                 _u._stringValue = new String(*(x._u._stringValue));                  CIMValueType<CIMInstance>::destruct(this);
                 break;  
   
             case CIMType::DATETIME:  
                 _u._dateTimeValue = new CIMDateTime(*(x._u._dateTimeValue));  
                 break;                 break;
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
           }
       }
   }
  
             case CIMType::REFERENCE:  //==============================================================================
                 _u._referenceValue  //
                     = new CIMReference(*(x._u._referenceValue));  // CIMValue
                 break;  //
   //==============================================================================
  
             // Should never get here. testing complete enum  static inline void _release(CIMValueRep*& rep)
             default:  {
                 throw CIMValueInvalidType();      if (rep->refs.get() == 1)
         }          rep->release();
       else
       {
           CIMValueRep::unref(rep);
           rep = new CIMValueRep;
     }     }
 } }
  
 Uint32 CIMValue::getArraySize() const  CIMValue::CIMValue(CIMType type, Boolean isArray, Uint32 arraySize)
 { {
     if (!_isArray)      _rep = new CIMValueRep;
         return 0;  
  
     switch (_type)      switch (type)
     {     {
         case CIMType::NONE:          case CIMTYPE_BOOLEAN:
             return 0;              CIMValueType<Boolean>::setNull(_rep, type, isArray, arraySize);
             break;             break;
  
         case CIMType::BOOLEAN:          case CIMTYPE_UINT8:
             return _u._booleanArray->size;              CIMValueType<Uint8>::setNull(_rep, type, isArray, arraySize);
             break;             break;
  
         case CIMType::UINT8:          case CIMTYPE_SINT8:
             return _u._uint8Array->size;              CIMValueType<Sint8>::setNull(_rep, type, isArray, arraySize);
             break;             break;
  
         case CIMType::SINT8:          case CIMTYPE_UINT16:
             return _u._sint8Array->size;              CIMValueType<Uint16>::setNull(_rep, type, isArray, arraySize);
             break;             break;
  
         case CIMType::UINT16:          case CIMTYPE_SINT16:
             return _u._uint16Array->size;              CIMValueType<Sint16>::setNull(_rep, type, isArray, arraySize);
             break;             break;
  
         case CIMType::SINT16:          case CIMTYPE_UINT32:
             return _u._sint16Array->size;              CIMValueType<Uint32>::setNull(_rep, type, isArray, arraySize);
             break;             break;
  
         case CIMType::UINT32:          case CIMTYPE_SINT32:
             return _u._uint32Array->size;              CIMValueType<Sint32>::setNull(_rep, type, isArray, arraySize);
             break;             break;
  
         case CIMType::SINT32:          case CIMTYPE_UINT64:
             return _u._sint32Array->size;              CIMValueType<Uint64>::setNull(_rep, type, isArray, arraySize);
             break;             break;
  
         case CIMType::UINT64:          case CIMTYPE_SINT64:
             return _u._uint64Array->size;              CIMValueType<Sint64>::setNull(_rep, type, isArray, arraySize);
             break;             break;
  
         case CIMType::SINT64:          case CIMTYPE_REAL32:
             return _u._sint64Array->size;              CIMValueType<Real32>::setNull(_rep, type, isArray, arraySize);
             break;             break;
  
         case CIMType::REAL32:          case CIMTYPE_REAL64:
             return _u._real32Array->size;              CIMValueType<Real64>::setNull(_rep, type, isArray, arraySize);
             break;             break;
  
         case CIMType::REAL64:          case CIMTYPE_CHAR16:
             return _u._real64Array->size;              CIMValueType<Char16>::setNull(_rep, type, isArray, arraySize);
             break;             break;
  
         case CIMType::CHAR16:          case CIMTYPE_STRING:
             return _u._char16Array->size;              CIMValueType<String>::setNull(_rep, type, isArray, arraySize);
             break;             break;
  
         case CIMType::STRING:          case CIMTYPE_DATETIME:
             return _u._stringArray->size;              CIMValueType<CIMDateTime>::setNull(_rep, type, isArray, arraySize);
             break;             break;
  
         case CIMType::DATETIME:          case CIMTYPE_REFERENCE:
             return _u._dateTimeArray->size;              CIMValueType<CIMObjectPath>::setNull(_rep, type, isArray,arraySize);
             break;             break;
  
         case CIMType::REFERENCE:          case CIMTYPE_OBJECT:
             return _u._referenceArray->size;              CIMValueType<CIMObject>::setNull(_rep, type, isArray, arraySize);
             break;             break;
         // Should never get here. switch on complete enum  #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
           case CIMTYPE_INSTANCE:
               CIMValueType<CIMInstance>::setNull(_rep, type, isArray, arraySize);
               break;
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
   
         default:         default:
             throw CIMValueInvalidType();              PEGASUS_ASSERT(0);
     }     }
   
     // Unreachable!  
     PEGASUS_ASSERT(false);  
     return 0;  
 } }
  
 //ATTN: P1  KS Problem with Compiler when I added the defaults to clear, the compiler  CIMValue::CIMValue(Boolean x)
 // 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)      _rep = new CIMValueRep;
         {      CIMValueType<Boolean>::set(_rep, x);
             case CIMType::BOOLEAN:  }
                 _Dec(_u._booleanArray);  
                 break;  
  
             case CIMType::UINT8:  CIMValue::CIMValue(Uint8 x)
                 _Dec(_u._uint8Array);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Uint8>::set(_rep, x);
   }
  
             case CIMType::SINT8:  CIMValue::CIMValue(Sint8 x)
                 _Dec(_u._sint8Array);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Sint8>::set(_rep, x);
   }
  
             case CIMType::UINT16:  CIMValue::CIMValue(Uint16 x)
                 _Dec(_u._uint16Array);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Uint16>::set(_rep, x);
   }
  
             case CIMType::SINT16:  CIMValue::CIMValue(Sint16 x)
                 _Dec(_u._sint16Array);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Sint16>::set(_rep, x);
   }
  
             case CIMType::UINT32:  CIMValue::CIMValue(Uint32 x)
                 _Dec(_u._uint32Array);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Uint32>::set(_rep, x);
   }
  
             case CIMType::SINT32:  CIMValue::CIMValue(Sint32 x)
                 _Dec(_u._sint32Array);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Sint32>::set(_rep, x);
   }
  
             case CIMType::UINT64:  CIMValue::CIMValue(Uint64 x)
                 _Dec(_u._uint64Array);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Uint64>::set(_rep, x);
   }
  
             case CIMType::SINT64:  CIMValue::CIMValue(Sint64 x)
                 _Dec(_u._sint64Array);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Sint64>::set(_rep, x);
   }
  
             case CIMType::REAL32:  CIMValue::CIMValue(Real32 x)
                 _Dec(_u._real32Array);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Real32>::set(_rep, x);
   }
  
             case CIMType::REAL64:  CIMValue::CIMValue(Real64 x)
                 _Dec(_u._real64Array);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Real64>::set(_rep, x);
   }
  
             case CIMType::CHAR16:  CIMValue::CIMValue(const Char16& x)
                 _Dec(_u._char16Array);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Char16>::set(_rep, x);
   }
  
             case CIMType::STRING:  CIMValue::CIMValue(const String& x)
                 _Dec(_u._stringArray);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<String>::set(_rep, x);
   }
  
             case CIMType::DATETIME:  CIMValue::CIMValue(const CIMDateTime& x)
                 _Dec(_u._dateTimeArray);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<CIMDateTime>::set(_rep, x);
   }
  
             case CIMType::REFERENCE:  CIMValue::CIMValue(const CIMObjectPath& x)
                 _Dec(_u._referenceArray);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<CIMObjectPath>::set(_rep, x);
   }
  
             //default:  CIMValue::CIMValue(const CIMObject& x)
                 //throw CIMValueInvalidType();  {
       if (x.isUninitialized())
       {
           // Bug 3373, throw exception if uninitialized object is passed to set().
           throw UninitializedObjectException();
         }         }
   
       _rep = new CIMValueRep;
       CIMValueType<CIMObject>::set(_rep, x.clone());
     }     }
     else  #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
   CIMValue::CIMValue(const CIMInstance& x)
     {     {
         switch (_type)      if (x.isUninitialized())
         {         {
             case CIMType::BOOLEAN:          // Bug 3373, throw exception if uninitialized object is passed to set().
             case CIMType::UINT8:          throw UninitializedObjectException();
             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;  
   
             case CIMType::STRING:  
                 delete _u._stringValue;  
                 break;  
   
             case CIMType::DATETIME:  
                 delete _u._dateTimeValue;  
                 break;  
  
             case CIMType::REFERENCE:      _rep = new CIMValueRep;
                 delete _u._referenceValue;      CIMValueType<CIMInstance>::set(_rep, x.clone());
                 break;  
             //default:  
                 //throw CIMValueInvalidType();  
         }         }
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
   CIMValue::CIMValue(const Array<Boolean>& x)
   {
       _rep = new CIMValueRep;
       CIMValueType<Boolean>::setArray(_rep, x);
     }     }
  
     _init();  CIMValue::CIMValue(const Array<Uint8>& x)
   {
       _rep = new CIMValueRep;
       CIMValueType<Uint8>::setArray(_rep, x);
 } }
  
 void CIMValue::toXml(Array<Sint8>& out, Boolean forceTag) const  CIMValue::CIMValue(const Array<Sint8>& x)
 { {
     /* If the CIMValue is Null, no element is returned.      _rep = new CIMValueRep;
      Note that it output absolutely nothing. This works for      CIMValueType<Sint8>::setArray(_rep, x);
      everything except qualifiers where the value tag is required in  }
      any case per the XML specification  
     */  
  
     if (_isNull)  CIMValue::CIMValue(const Array<Uint16>& x)
     {     {
         if (forceTag)      _rep = new CIMValueRep;
             if (_isArray)      CIMValueType<Uint16>::setArray(_rep, x);
                 out << "<VALUE.ARRAY></VALUE.ARRAY>\n";  
             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++)  CIMValue::CIMValue(const Array<Sint16>& x)
                 {                 {
                     out << "<VALUE>";      _rep = new CIMValueRep;
                     _toXml(out, Boolean(_u._booleanArray->data()[i]));      CIMValueType<Sint16>::setArray(_rep, x);
                     out << "</VALUE>\n";  
                 }                 }
  
                 out << "</VALUE.ARRAY>\n";  CIMValue::CIMValue(const Array<Uint32>& x)
                 break;  {
       _rep = new CIMValueRep;
       CIMValueType<Uint32>::setArray(_rep, x);
             }             }
  
             case CIMType::UINT8:  CIMValue::CIMValue(const Array<Sint32>& x)
                 _toXml(out, _u._uint8Array->data(), _u._uint8Array->size);  
                 break;  
   
             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:  
                 _toXml(out, _u._sint64Array->data(), _u._sint64Array->size);  
                 break;  
   
             case CIMType::REAL32:  
                 _toXml(out, _u._real32Array->data(), _u._real32Array->size);  
                 break;  
   
             case CIMType::REAL64:  
                 _toXml(out, _u._real64Array->data(), _u._real64Array->size);  
                 break;  
   
             case CIMType::CHAR16:  
                 _toXml(out, _u._char16Array->data(), _u._char16Array->size);  
                 break;  
   
             case CIMType::STRING:  
                 _toXml(out, _u._stringArray->data(), _u._stringArray->size);  
                 break;  
   
             case CIMType::DATETIME:  
                 _toXml(out, _u._dateTimeArray->data(), _u._dateTimeArray->size);  
                 break;  
   
             case CIMType::REFERENCE:  
                 _toXml(out, _u._referenceArray->data(),  
                             _u._referenceArray->size);  
                 break;  
   
             default:  
                 throw CIMValueInvalidType();  
         }  
     }  
     else if (_type == CIMType::REFERENCE)  
     {     {
         // Has to be separate because it uses VALUE.REFERENCE tag      _rep = new CIMValueRep;
         _toXml(out, *_u._referenceValue);      CIMValueType<Sint32>::setArray(_rep, x);
     }     }
     else  
     {  
         out << "<VALUE>";  
  
         switch (_type)  CIMValue::CIMValue(const Array<Uint64>& x)
         {         {
             case CIMType::BOOLEAN:      _rep = new CIMValueRep;
                 _toXml(out, Boolean(_u._booleanValue != 0));      CIMValueType<Uint64>::setArray(_rep, x);
                 break;  }
  
             case CIMType::UINT8:  CIMValue::CIMValue(const Array<Sint64>& x)
                 _toXml(out, _u._uint8Value);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Sint64>::setArray(_rep, x);
   }
  
             case CIMType::SINT8:  CIMValue::CIMValue(const Array<Real32>& x)
                 _toXml(out, _u._sint8Value);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Real32>::setArray(_rep, x);
   }
  
             case CIMType::UINT16:  CIMValue::CIMValue(const Array<Real64>& x)
                 _toXml(out, _u._uint16Value);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Real64>::setArray(_rep, x);
   }
  
             case CIMType::SINT16:  CIMValue::CIMValue(const Array<Char16>& x)
                 _toXml(out, _u._sint16Value);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Char16>::setArray(_rep, x);
   }
  
             case CIMType::UINT32:  CIMValue::CIMValue(const Array<String>& x)
                 _toXml(out, _u._uint32Value);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<String>::setArray(_rep, x);
   }
  
             case CIMType::SINT32:  CIMValue::CIMValue(const Array<CIMDateTime>& x)
                 _toXml(out, _u._sint32Value);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<CIMDateTime>::setArray(_rep, x);
   }
  
             case CIMType::UINT64:  CIMValue::CIMValue(const Array<CIMObjectPath>& x)
                 _toXml(out, _u._uint64Value);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<CIMObjectPath>::setArray(_rep, x);
   }
  
             case CIMType::SINT64:  CIMValue::CIMValue(const Array<CIMObject>& x)
                 _toXml(out, _u._sint64Value);  {
                 break;      Array<CIMObject> tmp;
  
             case CIMType::REAL32:      for (Uint32 i = 0, n = x.size(); i < n; i++)
                 _toXml(out, _u._real32Value);      {
                 break;          if (x[i].isUninitialized())
           {
               // Bug 3373, throw exception on uninitialized object.
               _rep = &CIMValueRep::_emptyRep;
               throw UninitializedObjectException();
           }
  
             case CIMType::REAL64:          tmp.append(x[i].clone());
                 _toXml(out, _u._real64Value);      }
                 break;  
  
             case CIMType::CHAR16:      _rep = new CIMValueRep;
                 _toXml(out, Char16(_u._char16Value));      CIMValueType<CIMObject>::setArray(_rep, tmp);
                 break;  }
  
             case CIMType::STRING:  #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
                 _toXml(out, *_u._stringValue);  CIMValue::CIMValue(const Array<CIMInstance>& x)
                 break;  {
       Array<CIMInstance> tmp;
  
             case CIMType::DATETIME:      for (Uint32 i = 0, n = x.size(); i < n; i++)
                 _toXml(out, *_u._dateTimeValue);      {
                 break;          if (x[i].isUninitialized())
             default:          {
                 throw CIMValueInvalidType();            // Bug 3373, throw exception on uninitialized object.
             _rep = &CIMValueRep::_emptyRep;
             throw UninitializedObjectException();
         }         }
  
         out << "</VALUE>\n";          tmp.append(x[i].clone());
     }     }
       _rep = new CIMValueRep;
       CIMValueType<CIMInstance>::setArray(_rep, tmp);
 } }
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
  
 String CIMValue::toXml(Boolean forceTag) const  void CIMValue::clear()
 { {
     Array<Sint8> out;      CIMValueRep::unref(_rep);
     toXml(out, forceTag);      _rep = &CIMValueRep::_emptyRep;
     out.append('\0');  
     return String(out.getData());  
 } }
  
 void CIMValue::toMof(Array<Sint8>& out) const  CIMValue& CIMValue::operator=(const CIMValue& x)
 { {
     // if the CIMValue is Null we return nothing.      if (_rep != x._rep)
     // The alternative is to return the Null indicator.  
     if (_isNull)  
     {     {
         out << "null";          CIMValueRep::unref(_rep);
         return ;          CIMValueRep::ref(_rep = x._rep);
     }     }
  
       return *this;
   }
  
     if (_isArray)  void CIMValue::assign(const CIMValue& x)
     {     {
         switch (_type)      if (_rep != x._rep)
         {         {
             case CIMType::BOOLEAN:          CIMValueRep::unref(_rep);
           CIMValueRep::ref(_rep = x._rep);
       }
   }
   
   Boolean CIMValue::typeCompatible(const CIMValue& x) const
             {             {
                 _toMof(out, _u._booleanArray->data(), _u._booleanArray->size);      return (_rep->type == x._rep->type && _rep->isArray == x._rep->isArray);
                 break;  
             }             }
             case CIMType::UINT8:  
                 _toMof(out, _u._uint8Array->data(), _u._uint8Array->size);  
                 break;  
  
             case CIMType::SINT8:  Uint32 CIMValue::getArraySize() const
                 _toMof(out, _u._sint8Array->data(), _u._sint8Array->size);  {
                 break;      if (!_rep->isArray)
           return 0;
  
             case CIMType::UINT16:      switch (_rep->type)
                 _toMof(out, _u._uint16Array->data(), _u._uint16Array->size);      {
                 break;          case CIMTYPE_BOOLEAN:
               return CIMValueType<Boolean>::arraySize(_rep);
  
             case CIMType::SINT16:          case CIMTYPE_UINT8:
                 _toMof(out, _u._sint16Array->data(), _u._sint16Array->size);              return CIMValueType<Uint8>::arraySize(_rep);
                 break;  
  
             case CIMType::UINT32:          case CIMTYPE_SINT8:
                 _toMof(out, _u._uint32Array->data(), _u._uint32Array->size);              return CIMValueType<Sint8>::arraySize(_rep);
                 break;  
  
             case CIMType::SINT32:          case CIMTYPE_UINT16:
                 _toMof(out, _u._sint32Array->data(), _u._sint32Array->size);              return CIMValueType<Uint16>::arraySize(_rep);
                 break;  
  
             case CIMType::UINT64:          case CIMTYPE_SINT16:
                 _toMof(out, _u._uint64Array->data(), _u._uint64Array->size);              return CIMValueType<Sint16>::arraySize(_rep);
                 break;  
  
             case CIMType::SINT64:          case CIMTYPE_UINT32:
                 _toMof(out, _u._sint64Array->data(), _u._sint64Array->size);              return CIMValueType<Uint32>::arraySize(_rep);
                 break;  
  
             case CIMType::REAL32:          case CIMTYPE_SINT32:
                 _toMof(out, _u._real32Array->data(), _u._real32Array->size);              return CIMValueType<Sint32>::arraySize(_rep);
                 break;  
  
             case CIMType::REAL64:          case CIMTYPE_UINT64:
                 _toMof(out, _u._real64Array->data(), _u._real64Array->size);              return CIMValueType<Uint64>::arraySize(_rep);
                 break;  
  
             case CIMType::CHAR16:          case CIMTYPE_SINT64:
                 _toMof(out, _u._char16Array->data(), _u._char16Array->size);              return CIMValueType<Sint64>::arraySize(_rep);
                 break;  
  
             case CIMType::STRING:          case CIMTYPE_REAL32:
                 _toMof(out, _u._stringArray->data(), _u._stringArray->size);              return CIMValueType<Real32>::arraySize(_rep);
                 break;  
  
             case CIMType::DATETIME:          case CIMTYPE_REAL64:
                 _toMof(out, _u._dateTimeArray->data(),              return CIMValueType<Real64>::arraySize(_rep);
                             _u._dateTimeArray->size);  
                 break;  
  
             case CIMType::REFERENCE:          case CIMTYPE_CHAR16:
                 _toMof(out, _u._referenceArray->data(),              return CIMValueType<Char16>::arraySize(_rep);
                             _u._referenceArray->size);  
                 break;          case CIMTYPE_STRING:
               return CIMValueType<String>::arraySize(_rep);
   
           case CIMTYPE_DATETIME:
               return CIMValueType<CIMDateTime>::arraySize(_rep);
  
           case CIMTYPE_REFERENCE:
               return CIMValueType<CIMObjectPath>::arraySize(_rep);
   
           case CIMTYPE_OBJECT:
               return CIMValueType<CIMObject>::arraySize(_rep);
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
           case CIMTYPE_INSTANCE:
           return CIMValueType<CIMInstance>::arraySize(_rep);
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
             default:             default:
                 throw CIMValueInvalidType();              PEGASUS_ASSERT(0);
         }         }
   
       return 0;
     }     }
     else  
   void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize)
     {     {
         switch (_type)      //
       // Release any memory:
       //
   
       _release(_rep);
   
       //
       // Set the null value:
       //
   
       switch (type)
         {         {
             case CIMType::BOOLEAN:          case CIMTYPE_BOOLEAN:
                 _toMof(out, Boolean(_u._booleanValue != 0));              CIMValueType<Boolean>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMType::UINT8:          case CIMTYPE_UINT8:
                 _toMof(out, _u._uint8Value);              CIMValueType<Uint8>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMType::SINT8:          case CIMTYPE_SINT8:
                 _toMof(out, _u._sint8Value);              CIMValueType<Sint8>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMType::UINT16:          case CIMTYPE_UINT16:
                 _toMof(out, _u._uint16Value);              CIMValueType<Uint16>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMType::SINT16:          case CIMTYPE_SINT16:
                 _toMof(out, _u._sint16Value);              CIMValueType<Sint16>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMType::UINT32:          case CIMTYPE_UINT32:
                 _toMof(out, _u._uint32Value);              CIMValueType<Uint32>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMType::SINT32:          case CIMTYPE_SINT32:
                 _toMof(out, _u._sint32Value);              CIMValueType<Sint32>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMType::UINT64:          case CIMTYPE_UINT64:
                 _toMof(out, _u._uint64Value);              CIMValueType<Uint64>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMType::SINT64:          case CIMTYPE_SINT64:
                 _toMof(out, _u._sint64Value);              CIMValueType<Sint64>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMType::REAL32:          case CIMTYPE_REAL32:
                 _toMof(out, _u._real32Value);              CIMValueType<Real32>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMType::REAL64:          case CIMTYPE_REAL64:
                 _toMof(out, _u._real64Value);              CIMValueType<Real64>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMType::CHAR16:          case CIMTYPE_CHAR16:
                 _toMof(out, Char16(_u._char16Value));              CIMValueType<Char16>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMType::STRING:          case CIMTYPE_STRING:
                 _toMof(out, *_u._stringValue);              CIMValueType<String>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMType::DATETIME:          case CIMTYPE_DATETIME:
                 _toMof(out, *_u._dateTimeValue);              CIMValueType<CIMDateTime>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMType::REFERENCE:          case CIMTYPE_REFERENCE:
                 _toMof(out, *_u._referenceValue);              CIMValueType<CIMObjectPath>::setNull(_rep, type, isArray,arraySize);
                 break;                 break;
  
           case CIMTYPE_OBJECT:
               CIMValueType<CIMObject>::setNull(_rep, type, isArray, arraySize);
               break;
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
           case CIMTYPE_INSTANCE:
               CIMValueType<CIMInstance>::setNull(_rep, type, isArray, arraySize);
               break;
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
             default:             default:
                 throw CIMValueInvalidType();              PEGASUS_ASSERT(0);
         }         }
     }     }
 }  
   
   
 void CIMValue::print( Boolean forceTag, PEGASUS_STD(ostream) &os) const  
 {  
     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();      _release(_rep);
     _u._booleanValue = (Uint8)x;      CIMValueType<Boolean>::set(_rep, x);
     _type = CIMType::BOOLEAN;  
     _isNull = false;  
 } }
  
 void CIMValue::set(Uint8 x) void CIMValue::set(Uint8 x)
 { {
     clear();      _release(_rep);
     _u._uint8Value = x;      CIMValueType<Uint8>::set(_rep, x);
     _type = CIMType::UINT8;  
     _isNull = false;  
 } }
  
 void CIMValue::set(Sint8 x) void CIMValue::set(Sint8 x)
 { {
     clear();      _release(_rep);
     _u._sint8Value = x;      CIMValueType<Sint8>::set(_rep, x);
     _type = CIMType::SINT8;  
     _isNull = false;  
 } }
  
 void CIMValue::set(Uint16 x) void CIMValue::set(Uint16 x)
 { {
     clear();      _release(_rep);
     _u._uint16Value = x;      CIMValueType<Uint16>::set(_rep, x);
     _type = CIMType::UINT16;  
     _isNull = false;  
 } }
  
 void CIMValue::set(Sint16 x) void CIMValue::set(Sint16 x)
 { {
     clear();      _release(_rep);
     _u._sint16Value = x;      CIMValueType<Sint16>::set(_rep, x);
     _type = CIMType::SINT16;  
     _isNull = false;  
 } }
  
 void CIMValue::set(Uint32 x) void CIMValue::set(Uint32 x)
 { {
     clear();      _release(_rep);
     _u._uint32Value = x;      CIMValueType<Uint32>::set(_rep, x);
     _type = CIMType::UINT32;  
     _isNull = false;  
 } }
  
 void CIMValue::set(Sint32 x) void CIMValue::set(Sint32 x)
 { {
     clear();      _release(_rep);
     _u._sint32Value = x;      CIMValueType<Sint32>::set(_rep, x);
     _type = CIMType::SINT32;  
     _isNull = false;  
 } }
  
 void CIMValue::set(Uint64 x) void CIMValue::set(Uint64 x)
 { {
     clear();      _release(_rep);
     _u._uint64Value = x;      CIMValueType<Uint64>::set(_rep, x);
     _type = CIMType::UINT64;  
     _isNull = false;  
 } }
  
 void CIMValue::set(Sint64 x) void CIMValue::set(Sint64 x)
 { {
     clear();      _release(_rep);
     _u._sint64Value = x;      CIMValueType<Sint64>::set(_rep, x);
     _type = CIMType::SINT64;  
     _isNull = false;  
 } }
  
 void CIMValue::set(Real32 x) void CIMValue::set(Real32 x)
 { {
     clear();      _release(_rep);
     _u._real32Value = x;      CIMValueType<Real32>::set(_rep, x);
     _type = CIMType::REAL32;  
     _isNull = false;  
 } }
  
 void CIMValue::set(Real64 x) void CIMValue::set(Real64 x)
 { {
     clear();      _release(_rep);
     _u._real64Value = x;      CIMValueType<Real64>::set(_rep, x);
     _type = CIMType::REAL64;  
     _isNull = false;  
 } }
  
 void CIMValue::set(const Char16& x) void CIMValue::set(const Char16& x)
 { {
     clear();      _release(_rep);
     _u._char16Value = x;      CIMValueType<Char16>::set(_rep, x);
     _type = CIMType::CHAR16;  
     _isNull = false;  
 } }
  
 void CIMValue::set(const String& x) void CIMValue::set(const String& x)
 { {
     clear();      _release(_rep);
     _u._stringValue = new String(x);      CIMValueType<String>::set(_rep, x);
     _type = CIMType::STRING;  
     _isNull = false;  
 } }
  
 void CIMValue::set(const char* x)  void CIMValue::set(const CIMDateTime& x)
 { {
     set(String(x));      _release(_rep);
     _isNull = false;      CIMValueType<CIMDateTime>::set(_rep, x);
 } }
  
 void CIMValue::set(const CIMDateTime& x)  void CIMValue::set(const CIMObjectPath& x)
 { {
     clear();      _release(_rep);
     _u._dateTimeValue = new CIMDateTime(x);      CIMValueType<CIMObjectPath>::set(_rep, x);
     _type = CIMType::DATETIME;  
     _isNull = false;  
 } }
  
 void CIMValue::set(const CIMReference& x)  void CIMValue::set(const CIMObject& x)
 {  {
     clear();      if (x.isUninitialized())
     _u._referenceValue = new CIMReference(x);      {
     _type = CIMType::REFERENCE;          // Bug 3373, throw exception on uninitialized object.
     _isNull = false;          throw UninitializedObjectException();
       }
   
       _release(_rep);
       CIMValueType<CIMObject>::set(_rep, x.clone());
   }
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
   void CIMValue::set(const CIMInstance& x)
   {
       if (x.isUninitialized())
       {
           // Bug 3373, throw exception on uninitialized object.
           throw UninitializedObjectException();
 } }
  
       _release(_rep);
       CIMValueType<CIMInstance>::set(_rep, x.clone());
   }
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
 void CIMValue::set(const Array<Boolean>& x) void CIMValue::set(const Array<Boolean>& x)
 { {
     clear();      _release(_rep);
     _Inc(_u._booleanArray = x._rep);      CIMValueType<Boolean>::setArray(_rep, x);
     _type = CIMType::BOOLEAN;  
     _isArray = true;  
     _isNull = false;  
 } }
  
 void CIMValue::set(const Array<Uint8>& x) void CIMValue::set(const Array<Uint8>& x)
 { {
     clear();      _release(_rep);
     _Inc(_u._uint8Array = x._rep);      CIMValueType<Uint8>::setArray(_rep, x);
     _type = CIMType::UINT8;  
     _isArray = true;  
     _isNull = false;  
 } }
  
 void CIMValue::set(const Array<Sint8>& x) void CIMValue::set(const Array<Sint8>& x)
 { {
     clear();      _release(_rep);
     _Inc(_u._sint8Array = x._rep);      CIMValueType<Sint8>::setArray(_rep, x);
     _type = CIMType::SINT8;  
     _isArray = true;  
     _isNull = false;  
 } }
  
 void CIMValue::set(const Array<Uint16>& x) void CIMValue::set(const Array<Uint16>& x)
 { {
     clear();      _release(_rep);
     _Inc(_u._uint16Array = x._rep);      CIMValueType<Uint16>::setArray(_rep, x);
     _type = CIMType::UINT16;  
     _isArray = true;  
     _isNull = false;  
 } }
  
 void CIMValue::set(const Array<Sint16>& x) void CIMValue::set(const Array<Sint16>& x)
 { {
     clear();      _release(_rep);
     _Inc(_u._sint16Array = x._rep);      CIMValueType<Sint16>::setArray(_rep, x);
     _type = CIMType::SINT16;  
     _isArray = true;  
     _isNull = false;  
 } }
  
 void CIMValue::set(const Array<Uint32>& x) void CIMValue::set(const Array<Uint32>& x)
 { {
     clear();      _release(_rep);
     _Inc(_u._uint32Array = x._rep);      CIMValueType<Uint32>::setArray(_rep, x);
     _type = CIMType::UINT32;  
     _isArray = true;  
     _isNull = false;  
 } }
  
 void CIMValue::set(const Array<Sint32>& x) void CIMValue::set(const Array<Sint32>& x)
 { {
     clear();      _release(_rep);
     _Inc(_u._sint32Array = x._rep);      CIMValueType<Sint32>::setArray(_rep, x);
     _type = CIMType::SINT32;  
     _isArray = true;  
     _isNull = false;  
 } }
  
 void CIMValue::set(const Array<Uint64>& x) void CIMValue::set(const Array<Uint64>& x)
 { {
     clear();      _release(_rep);
     _Inc(_u._uint64Array = x._rep);      CIMValueType<Uint64>::setArray(_rep, x);
     _type = CIMType::UINT64;  
     _isArray = true;  
     _isNull = false;  
 } }
  
 void CIMValue::set(const Array<Sint64>& x) void CIMValue::set(const Array<Sint64>& x)
 { {
     clear();      _release(_rep);
     _Inc(_u._sint64Array = x._rep);      CIMValueType<Sint64>::setArray(_rep, x);
     _type = CIMType::SINT64;  
     _isArray = true;  
     _isNull = false;  
 } }
  
 void CIMValue::set(const Array<Real32>& x) void CIMValue::set(const Array<Real32>& x)
 { {
     clear();      _release(_rep);
     _Inc(_u._real32Array = x._rep);      CIMValueType<Real32>::setArray(_rep, x);
     _type = CIMType::REAL32;  
     _isArray = true;  
     _isNull = false;  
 } }
  
 void CIMValue::set(const Array<Real64>& x) void CIMValue::set(const Array<Real64>& x)
 { {
     clear();      _release(_rep);
     _Inc(_u._real64Array = x._rep);      CIMValueType<Real64>::setArray(_rep, x);
     _type = CIMType::REAL64;  
     _isArray = true;  
     _isNull = false;  
 } }
  
 void CIMValue::set(const Array<Char16>& x) void CIMValue::set(const Array<Char16>& x)
 { {
     clear();      _release(_rep);
     _Inc(_u._char16Array = x._rep);      CIMValueType<Char16>::setArray(_rep, x);
     _type = CIMType::CHAR16;  
     _isArray = true;  
     _isNull = false;  
 } }
  
 void CIMValue::set(const Array<String>& x) void CIMValue::set(const Array<String>& x)
 { {
     clear();      _release(_rep);
     _Inc(_u._stringArray = x._rep);      CIMValueType<String>::setArray(_rep, x);
     _type = CIMType::STRING;  
     _isArray = true;  
     _isNull = false;  
 } }
  
 void CIMValue::set(const Array<CIMDateTime>& x) void CIMValue::set(const Array<CIMDateTime>& x)
 { {
     clear();      _release(_rep);
     _Inc(_u._dateTimeArray = x._rep);      CIMValueType<CIMDateTime>::setArray(_rep, x);
     _type = CIMType::DATETIME;  }
     _isArray = true;  
     _isNull = false;  void CIMValue::set(const Array<CIMObjectPath>& x)
   {
       _release(_rep);
       CIMValueType<CIMObjectPath>::setArray(_rep, x);
   }
   
   void CIMValue::set(const Array<CIMObject>& a)
   {
       Array<CIMObject> tmp;
   
       for (Uint32 i = 0, n = a.size(); i < n; i++)
       {
           if (a[i].isUninitialized())
           {
               // Bug 3373, throw exception on uninitialized object.
               throw UninitializedObjectException();
           }
   
           tmp.append(a[i].clone());
       }
   
       _release(_rep);
       CIMValueType<CIMObject>::setArray(_rep, tmp);
   }
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
   void CIMValue::set(const Array<CIMInstance>& a)
   {
       Array<CIMInstance> tmp;
   
       for (Uint32 i = 0, n = a.size(); i < n; i++)
       {
           if (a[i].isUninitialized())
           {
                     // Bug 3373, throw exception on uninitialized object.
                     throw UninitializedObjectException();
 } }
  
 void CIMValue::set(const Array<CIMReference>& x)          tmp.append(a[i].clone());
 {  
     clear();  
     _Inc(_u._referenceArray = x._rep);  
     _type = CIMType::REFERENCE;  
     _isArray = true;  
     _isNull = false;  
 } }
  
       _release(_rep);
       CIMValueType<CIMInstance>::setArray(_rep, tmp);
   }
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
 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 = CIMValueType<Boolean>::ref(_rep);
 } }
  
 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 = CIMValueType<Uint8>::ref(_rep);
 } }
  
 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 = CIMValueType<Sint8>::ref(_rep);
 } }
  
 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 = CIMValueType<Uint16>::ref(_rep);
 } }
  
 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 = CIMValueType<Sint16>::ref(_rep);
 } }
  
   
 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 = CIMValueType<Uint32>::ref(_rep);
 } }
  
 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 = CIMValueType<Sint32>::ref(_rep);
 } }
  
 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 = CIMValueType<Uint64>::ref(_rep);
 } }
  
 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 = CIMValueType<Sint64>::ref(_rep);
 } }
  
 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 = CIMValueType<Real32>::ref(_rep);
 } }
  
 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 = CIMValueType<Real64>::ref(_rep);
 } }
  
 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 = CIMValueType<Char16>::ref(_rep);
 } }
  
 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 = CIMValueType<String>::ref(_rep);
 } }
  
 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 = CIMValueType<CIMDateTime>::ref(_rep);
   }
   
   void CIMValue::get(CIMObjectPath& x) const
   {
       if (_rep->type != CIMTYPE_REFERENCE || _rep->isArray)
           throw TypeMismatchException();
  
     x = *_u._dateTimeValue;      if (!_rep->isNull)
           x = CIMValueType<CIMObjectPath>::ref(_rep);
 } }
  
 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)
           // We have to clone our own unique copy since we are about to
           // return an object to the caller that he can modify; thereby,
           // changing the one we refer to as well.
           x = CIMValueType<CIMObject>::ref(_rep).clone();
 } }
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
   void CIMValue::get(CIMInstance& x) const
   {
       if (_rep->type != CIMTYPE_INSTANCE || _rep->isArray)
           throw TypeMismatchException();
   
       if (!_rep->isNull)
       {
           if (_rep->refs.get() != 1)
           {
               // We have to make our own unique copy since we are about to
               // return an object to the caller that he can modify; thereby,
               // changing the one we refer to as well.
  
               CIMInstance tmp = CIMValueType<CIMInstance>::ref(_rep);
               ((CIMValue*)this)->set(tmp);
           }
   
           x = CIMValueType<CIMInstance>::ref(_rep);
       }
   }
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
 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 = CIMValueType<Boolean>::aref(_rep);
 } }
  
 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 = CIMValueType<Uint8>::aref(_rep);
 } }
  
 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 = CIMValueType<Sint8>::aref(_rep);
 } }
  
 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 = CIMValueType<Uint16>::aref(_rep);
 } }
  
 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 = CIMValueType<Sint16>::aref(_rep);
 } }
  
 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 = CIMValueType<Uint32>::aref(_rep);
 } }
  
 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 = CIMValueType<Sint32>::aref(_rep);
 } }
  
 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 = CIMValueType<Uint64>::aref(_rep);
 } }
  
 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 = CIMValueType<Sint64>::aref(_rep);
 } }
  
 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 = CIMValueType<Real32>::aref(_rep);
 } }
  
 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 = CIMValueType<Real64>::aref(_rep);
 } }
  
 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 = CIMValueType<Char16>::aref(_rep);
 } }
  
 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 = CIMValueType<String>::aref(_rep);
 } }
  
 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)      if (!_rep->isNull)
         throw TypeMismatch();          x = CIMValueType<CIMDateTime>::aref(_rep);
   }
   
   void CIMValue::get(Array<CIMObjectPath>& x) const
   {
       if (_rep->type != CIMTYPE_REFERENCE || !_rep->isArray)
           throw TypeMismatchException();
  
     x.set(_u._dateTimeArray);      if (!_rep->isNull)
           x = CIMValueType<CIMObjectPath>::aref(_rep);
 } }
  
 void CIMValue::get(Array<CIMReference>& x) const  void CIMValue::get(Array<CIMObject>& x) const
   {
       if (_rep->type != CIMTYPE_OBJECT || !_rep->isArray)
           throw TypeMismatchException();
   
       if (!_rep->isNull)
 { {
     if (_type != CIMType::REFERENCE || !_isArray)          x.clear();
         throw TypeMismatch();  
  
     x.set(_u._referenceArray);          // We have to clone our own unique copy since we are about to
           // return an object to the caller that he can modify; thereby,
           // changing the one we refer to as well.
           for (Uint32 i = 0, n = CIMValueType<CIMObject>::arraySize(_rep); i < n; i++)
           {
               x.append(CIMValueType<CIMObject>::aref(_rep)[i].clone());
           }
       }
 } }
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
   void CIMValue::get(Array<CIMInstance>& x) const
   {
       if (_rep->type != CIMTYPE_INSTANCE || !_rep->isArray)
           throw TypeMismatchException();
  
 void CIMValue::_init()      if (!_rep->isNull)
       {
           if (_rep->refs.get() != 1)
 { {
     _type = CIMType::NONE;              // We have to make our own unique copy since we are about to
     _isArray = false;              // return an object to the caller that he can modify; thereby,
     _isNull = true;              // changing the one we refer to as well.
     _u._voidPtr = 0;              Array<CIMInstance> tmp = CIMValueType<CIMInstance>::aref(_rep);
               ((CIMValue*)this)->set(tmp);
 } }
  
 Boolean operator==(const CIMValue& x, const CIMValue& y)          x = CIMValueType<CIMInstance>::aref(_rep);
       }
   }
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
   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 CIMValueType<Boolean>::equalArray(_rep, x._rep);
                     Array<Boolean>(y._u._booleanArray);  
               case CIMTYPE_UINT8:
                   return CIMValueType<Uint8>::equalArray(_rep, x._rep);
  
             case CIMType::UINT8:              case CIMTYPE_SINT8:
                 return Array<Uint8>(x._u._uint8Array) ==                  return CIMValueType<Sint8>::equalArray(_rep, x._rep);
                     Array<Uint8>(y._u._uint8Array);  
  
             case CIMType::SINT8:              case CIMTYPE_UINT16:
                 return Array<Sint8>(x._u._sint8Array) ==                  return CIMValueType<Uint16>::equalArray(_rep, x._rep);
                     Array<Sint8>(y._u._sint8Array);  
  
             case CIMType::UINT16:              case CIMTYPE_SINT16:
                 return Array<Uint16>(x._u._uint16Array) ==                  return CIMValueType<Sint16>::equalArray(_rep, x._rep);
                     Array<Uint16>(y._u._uint16Array);  
  
             case CIMType::SINT16:              case CIMTYPE_UINT32:
                 return Array<Sint16>(x._u._sint16Array) ==                  return CIMValueType<Uint32>::equalArray(_rep, x._rep);
                     Array<Sint16>(y._u._sint16Array);  
  
             case CIMType::UINT32:              case CIMTYPE_SINT32:
                 return Array<Uint32>(x._u._uint32Array) ==                  return CIMValueType<Sint32>::equalArray(_rep, x._rep);
                     Array<Uint32>(y._u._uint32Array);  
  
             case CIMType::SINT32:              case CIMTYPE_UINT64:
                 return Array<Sint32>(x._u._sint32Array) ==                  return CIMValueType<Uint64>::equalArray(_rep, x._rep);
                     Array<Sint32>(y._u._sint32Array);  
  
             case CIMType::UINT64:              case CIMTYPE_SINT64:
                 return Array<Uint64>(x._u._uint64Array) ==                  return CIMValueType<Sint64>::equalArray(_rep, x._rep);
                     Array<Uint64>(y._u._uint64Array);  
  
             case CIMType::SINT64:              case CIMTYPE_REAL32:
                 return Array<Sint64>(x._u._sint64Array) ==                  return CIMValueType<Real32>::equalArray(_rep, x._rep);
                     Array<Sint64>(y._u._sint64Array);  
  
             case CIMType::REAL32:              case CIMTYPE_REAL64:
                 return Array<Real32>(x._u._real32Array) ==                  return CIMValueType<Real64>::equalArray(_rep, x._rep);
                     Array<Real32>(y._u._real32Array);  
  
             case CIMType::REAL64:              case CIMTYPE_CHAR16:
                 return Array<Real64>(x._u._real64Array) ==                  return CIMValueType<Char16>::equalArray(_rep, x._rep);
                     Array<Real64>(y._u._real64Array);  
  
             case CIMType::CHAR16:              case CIMTYPE_STRING:
                 return Array<Char16>(x._u._char16Array) ==                  return CIMValueType<String>::equalArray(_rep, x._rep);
                     Array<Char16>(y._u._char16Array);  
  
             case CIMType::STRING:              case CIMTYPE_DATETIME:
                 return Array<String>(x._u._stringArray) ==                  return CIMValueType<CIMDateTime>::equalArray(_rep, x._rep);
                     Array<String>(y._u._stringArray);  
  
             case CIMType::DATETIME:              case CIMTYPE_REFERENCE:
                 return Array<CIMDateTime>(x._u._dateTimeArray) ==                  return CIMValueType<CIMObjectPath>::equalArray(_rep, x._rep);
                     Array<CIMDateTime>(y._u._dateTimeArray);  
  
             case CIMType::REFERENCE:              case CIMTYPE_OBJECT:
                 return Array<CIMReference>(x._u._referenceArray) ==                  return CIMValueType<CIMObject>::equalArray(_rep, x._rep);
                     Array<CIMReference>(y._u._referenceArray);  #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
               case CIMTYPE_INSTANCE:
                   return CIMValueType<CIMInstance>::equalArray(_rep, x._rep);
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
             default:             default:
                 throw CIMValueInvalidType();                  PEGASUS_ASSERT(0);
         }         }
     }     }
     else     else
     {     {
         switch (x._type)          switch (_rep->type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 return x._u._booleanValue == y._u._booleanValue;                  return CIMValueType<Boolean>::equal(_rep, x._rep);
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 return x._u._uint8Value == y._u._uint8Value;                  return CIMValueType<Uint8>::equal(_rep, x._rep);
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 return x._u._sint8Value == y._u._sint8Value;                  return CIMValueType<Sint8>::equal(_rep, x._rep);
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 return x._u._uint16Value == y._u._uint16Value;                  return CIMValueType<Uint16>::equal(_rep, x._rep);
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 return x._u._sint16Value == y._u._sint16Value;                  return CIMValueType<Sint16>::equal(_rep, x._rep);
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 return x._u._uint32Value == y._u._uint32Value;                  return CIMValueType<Uint32>::equal(_rep, x._rep);
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 return x._u._sint32Value == y._u._sint32Value;                  return CIMValueType<Sint32>::equal(_rep, x._rep);
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 return x._u._uint64Value == y._u._uint64Value;                  return CIMValueType<Uint64>::equal(_rep, x._rep);
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 return x._u._sint64Value == y._u._sint64Value;                  return CIMValueType<Sint64>::equal(_rep, x._rep);
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 return x._u._real32Value == y._u._real32Value;                  return CIMValueType<Real32>::equal(_rep, x._rep);
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 return x._u._real64Value == y._u._real64Value;                  return CIMValueType<Real64>::equal(_rep, x._rep);
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 return x._u._char16Value == y._u._char16Value;                  return CIMValueType<Char16>::equal(_rep, x._rep);
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 return String::equal(*x._u._stringValue, *y._u._stringValue);                  return CIMValueType<String>::equal(_rep, x._rep);
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 return *x._u._dateTimeValue == *y._u._dateTimeValue;                  return CIMValueType<CIMDateTime>::equal(_rep, x._rep);
  
             case CIMType::REFERENCE:              case CIMTYPE_REFERENCE:
                 return *x._u._referenceValue == *y._u._referenceValue;                  return CIMValueType<CIMObjectPath>::equal(_rep, x._rep);
   
               case CIMTYPE_OBJECT:
                   return CIMValueType<CIMObject>::ref(_rep).identical(
                       CIMValueType<CIMObject>::ref(x._rep));
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
               case CIMTYPE_INSTANCE:
                   return CIMValueType<CIMInstance>::ref(_rep).identical(
                       CIMValueType<CIMInstance>::ref(x._rep));
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
             default:             default:
                 throw CIMValueInvalidType();                  PEGASUS_ASSERT(0);
         }         }
     }     }
  
     // Unreachable!  
     return false;     return false;
 } }
  
 void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize)  String CIMValue::toString() const
 { {
       Buffer out;
  
     clear();      // ATTN: Not sure what we should do with getstring for Null CIMValues
       // Choice return empty string or exception out.
  
     if (isArray)      if (_rep->isNull)
           return String();
   
       if (_rep->isArray)
     {     {
         switch (type)          switch (_rep->type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 set(Array<Boolean>(arraySize));              {
                 break;                  const Array<Boolean>& a = CIMValueType<Boolean>::aref(_rep);
                   Uint32 size = a.size();
             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:  
                 set(Array<String>(arraySize));  
                 break;  
  
             case CIMType::DATETIME:                  for (Uint32 i = 0; i < size; i++)
                 set(Array<CIMDateTime>(arraySize));                  {
                       _toString(out, a[i]);
                       out.append(' ');
                   }
                 break;                 break;
               }
  
             case CIMType::REFERENCE:              case CIMTYPE_UINT8:
                 set(Array<CIMReference>(arraySize));              {
                   const Array<Uint8>& a = CIMValueType<Uint8>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
             default:  
                 throw CIMValueInvalidType();  
         }         }
     }  
     else              case CIMTYPE_SINT8:
     {  
         switch (type)  
         {         {
             case CIMType::BOOLEAN:                  const Array<Sint8>& a = CIMValueType<Sint8>::aref(_rep);
                 set(false);                  _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMType::UINT8:              case CIMTYPE_UINT16:
                 set(Uint8(0));              {
                   const Array<Uint16>& a = CIMValueType<Uint16>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMType::SINT8:              case CIMTYPE_SINT16:
                 set(Sint8(0));              {
                   const Array<Sint16>& a = CIMValueType<Sint16>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMType::UINT16:              case CIMTYPE_UINT32:
                 set(Uint16(0));              {
                   const Array<Uint32>& a = CIMValueType<Uint32>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMType::SINT16:              case CIMTYPE_SINT32:
                 set(Sint16(0));              {
                   const Array<Sint32>& a = CIMValueType<Sint32>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMType::UINT32:              case CIMTYPE_UINT64:
                 set(Uint32(0));              {
                   const Array<Uint64>& a = CIMValueType<Uint64>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMType::SINT32:              case CIMTYPE_SINT64:
                 set(Sint32(0));              {
                   const Array<Sint64>& a = CIMValueType<Sint64>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMType::UINT64:              case CIMTYPE_REAL32:
                 set(Uint64(0));              {
                   const Array<Real32>& a = CIMValueType<Real32>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMType::SINT64:              case CIMTYPE_REAL64:
                 set(Sint64(0));              {
                   const Array<Real64>& a = CIMValueType<Real64>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMType::REAL32:              case CIMTYPE_CHAR16:
                 set(Real32(0.0));              {
                   const Array<Char16>& a = CIMValueType<Char16>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMType::REAL64:              case CIMTYPE_STRING:
                 set(Real64(0.0));              {
                   const Array<String>& a = CIMValueType<String>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMType::CHAR16:              case CIMTYPE_DATETIME:
                 set(Char16(0));              {
                   const Array<CIMDateTime>& a =
                       CIMValueType<CIMDateTime>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMType::STRING:              case CIMTYPE_REFERENCE:
                 set(String());              {
                   const Array<CIMObjectPath>& a =
                       CIMValueType<CIMObjectPath>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMType::DATETIME:              case CIMTYPE_OBJECT:
                 set(CIMDateTime());              {
                   const Array<CIMObject>& a = CIMValueType<CIMObject>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
             case CIMType::REFERENCE:  #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
                 set(CIMReference());              case CIMTYPE_INSTANCE:
               {
                   const Array<CIMInstance>& a =
                       CIMValueType<CIMInstance>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
             default:  
                 throw CIMValueInvalidType();  
         }         }
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
               default:
                   PEGASUS_ASSERT(0);
     }     }
   
     // Set the Null attribute. Note that this must be after the set  
     // because the set functions sets the _isNull.  
   
     _isNull = true;  
 } }
       else
 String CIMValue::toString() const  
 {  
     Array<Sint8> out;  
   
     //ATTN: Not sure what we should do with getstring for Null CIMValues  
     //Choice return empty string or exception out.  
     if (_isNull)  
         return String();  
   
     if (_isArray)  
     {  
         switch (_type)  
         {  
             case CIMType::BOOLEAN:  
             {             {
                 int size = _u._booleanArray->size;          switch (_rep->type)
                 bool *p = _u._booleanArray->data();  
                 for (Uint32 i = 0; i < _u._booleanArray->size; i++)  
                 {                 {
                     _toString(out, Boolean(_u._booleanArray->data()[i]));              case CIMTYPE_BOOLEAN:
                     out << " ";                  _toString(out, CIMValueType<Boolean>::ref(_rep));
                 }  
                 break;                 break;
             }  
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 _toString(out, _u._uint8Array->data(), _u._uint8Array->size);                  _toString(out, CIMValueType<Uint8>::ref(_rep));
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 _toString(out, _u._sint8Array->data(), _u._sint8Array->size);                  _toString(out, CIMValueType<Sint8>::ref(_rep));
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 _toString(out, _u._uint16Array->data(), _u._uint16Array->size);                  _toString(out, CIMValueType<Uint16>::ref(_rep));
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 _toString(out, _u._sint16Array->data(), _u._sint16Array->size);                  _toString(out, CIMValueType<Sint16>::ref(_rep));
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 _toString(out, _u._uint32Array->data(), _u._uint32Array->size);                  _toString(out, CIMValueType<Uint32>::ref(_rep));
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 _toString(out, _u._sint32Array->data(), _u._sint32Array->size);                  _toString(out, CIMValueType<Sint32>::ref(_rep));
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 _toString(out, _u._uint64Array->data(), _u._uint64Array->size);                  _toString(out, CIMValueType<Uint64>::ref(_rep));
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 _toString(out, _u._sint64Array->data(), _u._sint64Array->size);                  _toString(out, CIMValueType<Sint64>::ref(_rep));
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 _toString(out, _u._real32Array->data(), _u._real32Array->size);                  _toString(out, CIMValueType<Real32>::ref(_rep));
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 _toString(out, _u._real64Array->data(), _u._real64Array->size);                  _toString(out, CIMValueType<Real64>::ref(_rep));
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 _toString(out, _u._char16Array->data(), _u._char16Array->size);                  _toString(out, CIMValueType<Char16>::ref(_rep));
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 _toString(out, _u._stringArray->data(), _u._stringArray->size);                  _toString(out, CIMValueType<String>::ref(_rep));
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 _toString(out, _u._dateTimeArray->data(), _u._dateTimeArray->size);                  _toString(out, CIMValueType<CIMDateTime>::ref(_rep));
                 break;                 break;
  
             case CIMType::REFERENCE:              case CIMTYPE_REFERENCE:
                 _toString(out, _u._referenceArray->data(), _u._referenceArray->size);                  _toString(out, CIMValueType<CIMObjectPath>::ref(_rep));
                 break;                 break;
  
               case CIMTYPE_OBJECT:
                   _toString(out, CIMValueType<CIMObject>::ref(_rep));
                   break;
   #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT
               case CIMTYPE_INSTANCE:
                   _toString(out, CIMValueType<CIMInstance>::ref(_rep));
                   break;
   #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT
             default:             default:
                 throw CIMValueInvalidType();                  PEGASUS_ASSERT(0);
         }         }
     }     }
     else  
     {  
         switch (_type)  
         {  
             case CIMType::BOOLEAN:  
                 _toString(out, Boolean(_u._booleanValue != 0));  
                 break;  
   
             case CIMType::UINT8:  
                 _toString(out, _u._uint8Value);  
                 break;  
   
             case CIMType::SINT8:  
                 _toString(out, _u._sint8Value);  
                 break;  
   
             case CIMType::UINT16:  
                 _toString(out, _u._uint16Value);  
                 break;  
   
             case CIMType::SINT16:  
                 _toString(out, _u._sint16Value);  
                 break;  
  
             case CIMType::UINT32:      out.append('\0');
                 _toString(out, _u._uint32Value);  
                 break;  
  
             case CIMType::SINT32:      return out.getData();
                 _toString(out, _u._sint32Value);  }
                 break;  
  
             case CIMType::UINT64:  #ifdef PEGASUS_USE_DEPRECATED_INTERFACES
                 _toString(out, _u._uint64Value);  
                 break;  
  
             case CIMType::SINT64:  CIMValue::CIMValue(char x)
                 _toString(out, _u._sint64Value);  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Sint8>::set(_rep, (Sint8)x);
   }
  
             case CIMType::REAL32:  CIMValue::CIMValue(const Array<char>& x)
                 _toString(out, _u._real32Value);  {
                 break;      _rep = new CIMValueRep;
       Array<Sint8> tmp((Sint8*)x.getData(), x.size());
       CIMValueType<Sint8>::setArray(_rep, tmp);
   }
  
             case CIMType::REAL64:  void CIMValue::set(char x)
                 _toString(out, _u._real64Value);  {
                 break;      set(static_cast<Sint8>(x));
   }
  
             case CIMType::CHAR16:  void CIMValue::set(const Array<char>& x)
                 _toString(out, Char16(_u._char16Value));  {
                 break;      set(*reinterpret_cast<const Array<Sint8>*>(&x));
   }
  
             case CIMType::STRING:  void CIMValue::get(char& x) const
                 _toString(out, *_u._stringValue);  {
                 break;      get(*reinterpret_cast<Sint8*>(&x));
   }
  
             case CIMType::DATETIME:  void CIMValue::get(Array<char>& x) const
                 _toString(out, *_u._dateTimeValue);  {
                 break;      get(*reinterpret_cast<Array<Sint8>*>(&x));
   }
  
             case CIMType::REFERENCE:  #endif /* PEGASUS_USE_DEPRECATED_INTERFACES */
                 _toString(out, *_u._referenceValue);  
                 break;  
  
             default:  void CIMValue::_get(const String*& data, Uint32& size) const
                 throw CIMValueInvalidType();  {
       const Array<String>& a = CIMValueType<String>::aref(_rep);
       data = a.getData();
       size = a.size();
         }         }
   
   Boolean operator==(const CIMValue& x, const CIMValue& y)
   {
       return x.equal(y);
     }     }
  
     out.append('\0');  Boolean operator!=(const CIMValue& x, const CIMValue& y)
     return out.getData();  {
       return !x.equal(y);
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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