(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.7 and 1.40

version 1.7, 2001/06/04 01:35:36 version 1.40, 2002/08/21 00:15:44
Line 1 
Line 1 
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
   // The Open Group, Tivoli Systems
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a  // Permission is hereby granted, free of charge, to any person obtaining a copy
 // copy of this software and associated documentation files (the "Software"),  // of this software and associated documentation files (the "Software"), to
 // to deal in the Software without restriction, including without limitation  // deal in the Software without restriction, including without limitation the
 // the rights to use, copy, modify, merge, publish, distribute, sublicense,  // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 // and/or sell copies of the Software, and to permit persons to whom the  // sell copies of the Software, and to permit persons to whom the Software is
 // Software is furnished to do so, subject to the following conditions:  // furnished to do so, subject to the following conditions:
 // //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL  // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING  // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER  // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 // DEALINGS IN THE SOFTWARE.  // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
   // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
   //              Karl Schopmeyer, (k.schopmeyer@opengroup.org)
   //              Carol Ann Krug Graves, Hewlett-Packard Company
   //                (carolann_graves@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <cstring> #include <cstring>
 #include <cstdio> #include <cstdio>
 #include <cassert>  
 #include <cctype> #include <cctype>
 #include "CIMValue.h" #include "CIMValue.h"
   #include "Union.h"
 #include "Indentor.h" #include "Indentor.h"
 #include "Exception.h"  
 #include "XmlWriter.h" #include "XmlWriter.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
Line 40 
Line 44 
 # include "ArrayImpl.h" # include "ArrayImpl.h"
 #undef PEGASUS_ARRAY_T #undef PEGASUS_ARRAY_T
  
 template<class T>  
 inline void _Inc(ArrayRep<T>* rep)  
 {  
     ArrayRep<T>::inc(rep);  
 }  
   
 template<class T>  
 inline void _Dec(ArrayRep<T>* rep)  
 {  
     ArrayRep<T>::dec(rep);  
 }  
   
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
 // Local helper functions:  // _toString routines:
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 //------------------------------------------------------------------------------  inline void _toString(Array<Sint8>& out, Boolean x)
 //  
 // _SignedIntToStr()  
 //  
 //------------------------------------------------------------------------------  
   
 static void _SignedIntToStr(Sint64 x, char* result)  
 { {
     if (!result)      XmlWriter::append(out, x);
         return;  
   
     if (x == 0)  
     {  
         result[0] = '0';  
         result[1] = '\0';  
         return;  
     }     }
  
     char buffer[256];  inline void _toString(Array<Sint8>& out, Uint8 x) { XmlWriter::append(out, Uint32(x)); }
     Uint32 len = 0;  inline void _toString(Array<Sint8>& out, Sint8 x) { XmlWriter::append(out, Sint32(x)); }
     Boolean negative = false;  inline void _toString(Array<Sint8>& out, Uint16 x) { XmlWriter::append(out, Uint32(x)); }
   inline void _toString(Array<Sint8>& out, Sint16 x) { XmlWriter::append(out, Sint32(x)); }
   inline void _toString(Array<Sint8>& out, Uint32 x) { XmlWriter::append(out, x); }
   inline void _toString(Array<Sint8>& out, Sint32 x) { XmlWriter::append(out, x); }
   inline void _toString(Array<Sint8>& out, Uint64 x) { XmlWriter::append(out, x); }
   inline void _toString(Array<Sint8>& out, Sint64 x) { XmlWriter::append(out, x); }
   inline void _toString(Array<Sint8>& out, Real32 x) { XmlWriter::append(out, Real64(x)); }
   inline void _toString(Array<Sint8>& out, Real64 x) { XmlWriter::append(out, x); }
  
     for (Uint32 i = 0; 1; i++)  inline void _toString(Array<Sint8>& out, Char16 x)
     {     {
         Sint64 q = x / 10;      // ATTN: How to convert 16-bit characters to printable form?
         Sint32 r = x % 10;      out.append(Sint8(x));
   }
         if (q == 0 && r == 0)  
             break;  
  
         if (r < 0)  inline void _toString(Array<Sint8>& out, const String& x)
         {         {
             r = -r;      out << x;
             negative = true;  
         }         }
  
         buffer[len++] = r + '0';  inline void _toString(Array<Sint8>& out, const CIMDateTime& x)
   {
       out << x.toString();
   }
  
         x = q ;  inline void _toString(Array<Sint8>& out, const CIMObjectPath& x)
   {
       out << x.toString();
     }     }
  
     buffer[len] = '\0';  template<class T>
   void _toString(Array<Sint8>& out, const T* p, Uint32 size)
   {
       while (size--)
       {
           _toString(out, *p++);
           out << " ";
       }
   }
  
     // If buffer was negative, prepend sign:  
  
     char* q = result;  ////////////////////////////////////////////////////////////////////////////////
   //
   // CIMValueRep
   //
   ////////////////////////////////////////////////////////////////////////////////
  
     if (negative)  class CIMValueRep
         *q++ = '-';  {
   public:
       CIMValueRep()
       {
           reset();
       }
  
     // Reverse the buffer:      ~CIMValueRep()
       {
       }
  
     char* p = &buffer[len];      void reset()
       {
           _type = CIMTYPE_BOOLEAN;
           _isArray = false;
           _isNull = true;
           _u._booleanValue = false;
       }
  
     while (len--)      CIMType _type;
         *q++ = *--p;      Boolean _isArray;
       Boolean _isNull;
       Union _u;
   };
  
     *q++ = '\0';  
 }  
  
 //------------------------------------------------------------------------------  ////////////////////////////////////////////////////////////////////////////////
 // //
 // _UnsignedIntToStr()  // CIMValue
 // //
 //------------------------------------------------------------------------------  ////////////////////////////////////////////////////////////////////////////////
  
 static void _UnsignedIntToStr(Uint64 x, char* result)  CIMValue::CIMValue()
 { {
     if (!result)      _rep = new CIMValueRep();
         return;  }
  
     if (x == 0)  CIMValue::CIMValue(CIMType type, Boolean isArray, Uint32 arraySize)
     {     {
         result[0] = '0';      _rep = new CIMValueRep();
         result[1] = '\0';      setNullValue(type, isArray, arraySize);
         return;  
     }     }
  
     char buffer[256];  CIMValue::CIMValue(Boolean x)
     Uint32 len = 0;  
     Boolean negative = false;  
   
     for (Uint32 i = 0; 1; i++)  
     {     {
         Sint64 q = x / 10;      _rep = new CIMValueRep();
         Sint32 r = x % 10;      set(x);
   
         if (q == 0 && r == 0)  
             break;  
   
         buffer[len++] = r + '0';  
   
         x = q ;  
     }     }
  
     buffer[len] = '\0';  CIMValue::CIMValue(Uint8 x)
   {
     // Reverse the buffer onto output:      _rep = new CIMValueRep();
       set(x);
     char* q = result;  }
   
     char* p = &buffer[len];  
  
     while (len--)  CIMValue::CIMValue(Sint8 x)
         *q++ = *--p;  {
       _rep = new CIMValueRep();
       set(x);
   }
  
     *q++ = '\0';  CIMValue::CIMValue(Uint16 x)
   {
       _rep = new CIMValueRep();
       set(x);
 } }
  
 //------------------------------------------------------------------------------  CIMValue::CIMValue(Sint16 x)
 //  {
 // _toXml() routines:      _rep = new CIMValueRep();
 //      set(x);
 //------------------------------------------------------------------------------  }
  
 inline void _toXml(Array<Sint8>& out, Boolean x)  CIMValue::CIMValue(Uint32 x)
 { {
     out << (x ? "TRUE" : "FALSE");      _rep = new CIMValueRep();
       set(x);
 } }
  
 template<class T>  CIMValue::CIMValue(Sint32 x)
 inline void _integerToXml(Array<Sint8>& out, const T& x)  
 { {
     char buffer[32];      _rep = new CIMValueRep();
     sprintf(buffer, "%d", x);      set(x);
     out << (char*)buffer;  
 } }
  
 inline void _toXml(Array<Sint8>& out, Uint8 x) { _integerToXml(out, x); }  CIMValue::CIMValue(Uint64 x)
   {
       _rep = new CIMValueRep();
       set(x);
   }
  
 inline void _toXml(Array<Sint8>& out, Sint8 x) { _integerToXml(out, x); }  CIMValue::CIMValue(Sint64 x)
   {
       _rep = new CIMValueRep();
       set(x);
   }
  
 inline void _toXml(Array<Sint8>& out, Uint16 x) { _integerToXml(out, x); }  CIMValue::CIMValue(Real32 x)
   {
       _rep = new CIMValueRep();
       set(x);
   }
  
 inline void _toXml(Array<Sint8>& out, Sint16 x) { _integerToXml(out, x); }  CIMValue::CIMValue(Real64 x)
   {
       _rep = new CIMValueRep();
       set(x);
   }
  
 inline void _toXml(Array<Sint8>& out, Uint32 x) { _integerToXml(out, x); }  CIMValue::CIMValue(const Char16& x)
   {
       _rep = new CIMValueRep();
       set(x);
   }
  
 inline void _toXml(Array<Sint8>& out, Sint32 x) { _integerToXml(out, x); }  CIMValue::CIMValue(const String& x)
   {
       _rep = new CIMValueRep();
       set(x);
   }
  
 inline void _toXml(Array<Sint8>& out, Uint64 x)  CIMValue::CIMValue(const CIMDateTime& x)
 { {
     char buffer[128];      _rep = new CIMValueRep();
     _UnsignedIntToStr(x, buffer);      set(x);
     out << buffer;  
 } }
  
 inline void _toXml(Array<Sint8>& out, Sint64 x)  CIMValue::CIMValue(const CIMObjectPath& x)
 { {
     char buffer[128];      _rep = new CIMValueRep();
     _SignedIntToStr(x, buffer);      set(x);
     out << buffer;  
 } }
  
 void _toXml(Array<Sint8>& out, Real32 x)  CIMValue::CIMValue(const Array<Boolean>& x)
 { {
     // ATTN: Does this format match the CIM/XML format?      _rep = new CIMValueRep();
     char buffer[128];      set(x);
     sprintf(buffer, "%f", x);  
     out << buffer;  
 } }
  
 void _toXml(Array<Sint8>& out, Real64 x)  CIMValue::CIMValue(const Array<Uint8>& x)
 { {
     char buffer[128];      _rep = new CIMValueRep();
     sprintf(buffer, "%f", x);      set(x);
     out << buffer;  
 } }
  
 inline void _toXml(Array<Sint8>& out, Char16 x)  CIMValue::CIMValue(const Array<Sint8>& x)
 { {
     XmlWriter::appendSpecial(out, x);      _rep = new CIMValueRep();
       set(x);
 } }
  
 inline void _toXml(Array<Sint8>& out, const String& x)  CIMValue::CIMValue(const Array<Uint16>& x)
 { {
     XmlWriter::appendSpecial(out, x);      _rep = new CIMValueRep();
       set(x);
 } }
  
 inline void _toXml(Array<Sint8>& out, const CIMDateTime& x)  CIMValue::CIMValue(const Array<Sint16>& x)
 { {
     out << x.getString();      _rep = new CIMValueRep();
       set(x);
 } }
  
 template<class T>  CIMValue::CIMValue(const Array<Uint32>& x)
 void _toXml(Array<Sint8>& out, const T* p, Uint32 size)  
 { {
     while (size--)      _rep = new CIMValueRep();
       set(x);
   }
   
   CIMValue::CIMValue(const Array<Sint32>& x)
     {     {
         out << "<VALUE>";      _rep = new CIMValueRep();
       set(x);
   }
  
         _toXml(out, *p++);  CIMValue::CIMValue(const Array<Uint64>& x)
   {
       _rep = new CIMValueRep();
       set(x);
   }
  
         out << "</VALUE>\n";  CIMValue::CIMValue(const Array<Sint64>& x)
   {
       _rep = new CIMValueRep();
       set(x);
     }     }
   
   CIMValue::CIMValue(const Array<Real32>& x)
   {
       _rep = new CIMValueRep();
       set(x);
 } }
  
 template<class T>  CIMValue::CIMValue(const Array<Real64>& x)
 void _toStr(Array<Sint8>& out, const T* p, Uint32 size)  
 { {
     while (size--)      _rep = new CIMValueRep();
       set(x);
   }
   
   CIMValue::CIMValue(const Array<Char16>& x)
     {     {
         _toXml(out, *p++);      _rep = new CIMValueRep();
         out << " ";      set(x);
     }     }
   
   CIMValue::CIMValue(const Array<String>& x)
   {
       _rep = new CIMValueRep();
       set(x);
 } }
  
 ////////////////////////////////////////////////////////////////////////////////  CIMValue::CIMValue(const Array<CIMDateTime>& x)
 //  {
 // CIMValue      _rep = new CIMValueRep();
 //      set(x);
 ////////////////////////////////////////////////////////////////////////////////  }
  
 CIMValue::CIMValue()  CIMValue::CIMValue(const Array<CIMObjectPath>& x)
 { {
     _init();      _rep = new CIMValueRep();
       set(x);
 } }
  
 CIMValue::CIMValue(const CIMValue& x) CIMValue::CIMValue(const CIMValue& x)
 { {
     _init();      _rep = new CIMValueRep();
     assign(x);     assign(x);
 } }
  
 CIMValue::~CIMValue() CIMValue::~CIMValue()
 { {
     clear();     clear();
       delete _rep;
   }
   
   CIMValue& CIMValue::operator=(const CIMValue& x)
   {
       assign(x);
       return *this;
 } }
  
 void CIMValue::assign(const CIMValue& x) void CIMValue::assign(const CIMValue& x)
Line 294 
Line 353 
  
     clear();     clear();
  
     _type = x._type;      _rep->_type = x._rep->_type;
     _isArray = x._isArray;      _rep->_isArray = x._rep->_isArray;
     _u._voidPtr = 0;      _rep->_isNull = x._rep->_isNull;
  
     if (_isArray)      if (_rep->_isArray)
     {     {
         switch (_type)          switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 _Inc(_u._booleanArray = x._u._booleanArray);                  _rep->_u._booleanArray =
                       new Array<Boolean>(*(x._rep->_u._booleanArray));
                   break;
   
               case CIMTYPE_UINT8:
                   _rep->_u._uint8Array =
                       new Array<Uint8>(*(x._rep->_u._uint8Array));
                 break;                 break;
  
             case CIMType::UINT8:              case CIMTYPE_SINT8:
                 _Inc(_u._uint8Array = x._u._uint8Array);                  _rep->_u._sint8Array =
                       new Array<Sint8>(*(x._rep->_u._sint8Array));
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_UINT16:
                 _Inc(_u._sint8Array = x._u._sint8Array);                  _rep->_u._uint16Array =
                       new Array<Uint16>(*(x._rep->_u._uint16Array));
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_SINT16:
                 _Inc(_u._uint16Array = x._u._uint16Array);                  _rep->_u._sint16Array =
                       new Array<Sint16>(*(x._rep->_u._sint16Array));
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_UINT32:
                 _Inc(_u._sint16Array = x._u._sint16Array);                  _rep->_u._uint32Array =
                       new Array<Uint32>(*(x._rep->_u._uint32Array));
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_SINT32:
                 _Inc(_u._uint32Array = x._u._uint32Array);                  _rep->_u._sint32Array =
                       new Array<Sint32>(*(x._rep->_u._sint32Array));
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_UINT64:
                 _Inc(_u._sint32Array = x._u._sint32Array);                  _rep->_u._uint64Array =
                       new Array<Uint64>(*(x._rep->_u._uint64Array));
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_SINT64:
                 _Inc(_u._uint64Array = x._u._uint64Array);                  _rep->_u._sint64Array =
                       new Array<Sint64>(*(x._rep->_u._sint64Array));
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_REAL32:
                 _Inc(_u._sint64Array = x._u._sint64Array);                  _rep->_u._real32Array =
                       new Array<Real32>(*(x._rep->_u._real32Array));
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL64:
                 _Inc(_u._real32Array = x._u._real32Array);                  _rep->_u._real64Array =
                       new Array<Real64>(*(x._rep->_u._real64Array));
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_CHAR16:
                 _Inc(_u._real64Array = x._u._real64Array);                  _rep->_u._char16Array =
                       new Array<Char16>(*(x._rep->_u._char16Array));
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_STRING:
                 _Inc(_u._char16Array = x._u._char16Array);                  _rep->_u._stringArray =
                       new Array<String>(*(x._rep->_u._stringArray));
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_DATETIME:
                 _Inc(_u._stringArray = x._u._stringArray);                  _rep->_u._dateTimeArray =
                       new Array<CIMDateTime>(*(x._rep->_u._dateTimeArray));
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_REFERENCE:
                 _Inc(_u._dateTimeArray = x._u._dateTimeArray);                  _rep->_u._referenceArray =
                       new Array<CIMObjectPath>(*(x._rep->_u._referenceArray));
                 break;                 break;
               default:
                   throw CIMValueInvalidTypeException();
         }         }
     }     }
     else     else
     {     {
         switch (_type)          switch (_rep->_type)
         {         {
             case CIMType::NONE:              case CIMTYPE_BOOLEAN:
                   _rep->_u._booleanValue = x._rep->_u._booleanValue;
                 break;                 break;
  
             case CIMType::BOOLEAN:              case CIMTYPE_UINT8:
                 _u._booleanValue = x._u._booleanValue;                  _rep->_u._uint8Value = x._rep->_u._uint8Value;
                 break;                 break;
  
             case CIMType::UINT8:              case CIMTYPE_SINT8:
                 _u._uint8Value = x._u._uint8Value;                  _rep->_u._sint8Value = x._rep->_u._sint8Value;
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_UINT16:
                 _u._sint8Value = x._u._sint8Value;                  _rep->_u._uint16Value = x._rep->_u._uint16Value;
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_SINT16:
                 _u._uint16Value = x._u._uint16Value;                  _rep->_u._sint16Value = x._rep->_u._sint16Value;
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_UINT32:
                 _u._sint16Value = x._u._sint16Value;                  _rep->_u._uint32Value = x._rep->_u._uint32Value;
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_SINT32:
                 _u._uint32Value = x._u._uint32Value;                  _rep->_u._sint32Value = x._rep->_u._sint32Value;
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_UINT64:
                 _u._sint32Value = x._u._sint32Value;                  _rep->_u._uint64Value = x._rep->_u._uint64Value;
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_SINT64:
                 _u._uint64Value = x._u._uint64Value;                  _rep->_u._sint64Value = x._rep->_u._sint64Value;
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_REAL32:
                 _u._sint64Value = x._u._sint64Value;                  _rep->_u._real32Value = x._rep->_u._real32Value;
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL64:
                 _u._real32Value = x._u._real32Value;                  _rep->_u._real64Value = x._rep->_u._real64Value;
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_CHAR16:
                 _u._real64Value = x._u._real64Value;                  _rep->_u._char16Value = x._rep->_u._char16Value;
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_STRING:
                 _u._char16Value = x._u._char16Value;                  _rep->_u._stringValue = new String(*(x._rep->_u._stringValue));
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_DATETIME:
                 _u._stringValue = new String(*(x._u._stringValue));                  _rep->_u._dateTimeValue =
                       new CIMDateTime(*(x._rep->_u._dateTimeValue));
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_REFERENCE:
                 _u._dateTimeValue = new CIMDateTime(*(x._u._dateTimeValue));                  _rep->_u._referenceValue =
                       new CIMObjectPath(*(x._rep->_u._referenceValue));
                 break;                 break;
  
             case CIMType::REFERENCE:              // Should never get here. testing complete enum
                 _u._referenceValue              default:
                     = new CIMReference(*(x._u._referenceValue));                  throw CIMValueInvalidTypeException();
                 break;  
         }         }
     }     }
 } }
  
 Uint32 CIMValue::getArraySize() const  //ATTN: P1  KS Problem with Compiler when I added the defaults to clear, the compiler
   // 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()
 { {
     if (!_isArray)      if (_rep->_isArray)
         return 0;  
   
     switch (_type)  
     {     {
         case CIMType::NONE:          switch (_rep->_type)
             return 0;          {
               case CIMTYPE_BOOLEAN:
                   delete _rep->_u._booleanArray;
             break;             break;
  
         case CIMType::BOOLEAN:              case CIMTYPE_UINT8:
             return _u._booleanArray->size;                  delete _rep->_u._uint8Array;
             break;             break;
  
         case CIMType::UINT8:              case CIMTYPE_SINT8:
             return _u._uint8Array->size;                  delete _rep->_u._sint8Array;
             break;             break;
  
         case CIMType::SINT8:              case CIMTYPE_UINT16:
             return _u._sint8Array->size;                  delete _rep->_u._uint16Array;
             break;             break;
  
         case CIMType::UINT16:              case CIMTYPE_SINT16:
             return _u._uint16Array->size;                  delete _rep->_u._sint16Array;
             break;             break;
  
         case CIMType::SINT16:              case CIMTYPE_UINT32:
             return _u._sint16Array->size;                  delete _rep->_u._uint32Array;
             break;             break;
  
         case CIMType::UINT32:              case CIMTYPE_SINT32:
             return _u._uint32Array->size;                  delete _rep->_u._sint32Array;
             break;             break;
  
         case CIMType::SINT32:              case CIMTYPE_UINT64:
             return _u._sint32Array->size;                  delete _rep->_u._uint64Array;
             break;             break;
  
         case CIMType::UINT64:              case CIMTYPE_SINT64:
             return _u._uint64Array->size;                  delete _rep->_u._sint64Array;
             break;             break;
  
         case CIMType::SINT64:              case CIMTYPE_REAL32:
             return _u._sint64Array->size;                  delete _rep->_u._real32Array;
             break;             break;
  
         case CIMType::REAL32:              case CIMTYPE_REAL64:
             return _u._real32Array->size;                  delete _rep->_u._real64Array;
             break;             break;
  
         case CIMType::REAL64:              case CIMTYPE_CHAR16:
             return _u._real64Array->size;                  delete _rep->_u._char16Array;
             break;             break;
  
         case CIMType::CHAR16:              case CIMTYPE_STRING:
             return _u._char16Array->size;                  delete _rep->_u._stringArray;
             break;             break;
  
         case CIMType::STRING:              case CIMTYPE_DATETIME:
             return _u._stringArray->size;                  delete _rep->_u._dateTimeArray;
             break;             break;
  
         case CIMType::DATETIME:              case CIMTYPE_REFERENCE:
             return _u._dateTimeArray->size;                  delete _rep->_u._referenceArray;
             break;             break;
  
         case CIMType::REFERENCE:              //default:
             return 0;                  //throw CIMValueInvalidTypeException();
     }     }
   
     // Unreachable!  
     return 0;  
 } }
       else
 void CIMValue::clear()  
 {  
     if (_isArray)  
     {     {
         switch (_type)          switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 _Dec(_u._booleanArray);              case CIMTYPE_UINT8:
               case CIMTYPE_SINT8:
               case CIMTYPE_UINT16:
               case CIMTYPE_SINT16:
               case CIMTYPE_UINT32:
               case CIMTYPE_SINT32:
               case CIMTYPE_UINT64:
               case CIMTYPE_SINT64:
               case CIMTYPE_REAL32:
               case CIMTYPE_REAL64:
               case CIMTYPE_CHAR16:
                   break;
   
               case CIMTYPE_STRING:
                   delete _rep->_u._stringValue;
                 break;                 break;
  
             case CIMType::UINT8:              case CIMTYPE_DATETIME:
                 _Dec(_u._uint8Array);                  delete _rep->_u._dateTimeValue;
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_REFERENCE:
                 _Dec(_u._sint8Array);                  delete _rep->_u._referenceValue;
                 break;                 break;
               //default:
                   //throw CIMValueInvalidTypeException();
           }
       }
   
       _rep->reset();
   }
  
             case CIMType::UINT16:  Boolean CIMValue::typeCompatible(const CIMValue& x) const
                 _Dec(_u._uint16Array);  {
       return (_rep->_type == x._rep->_type &&
               _rep->_isArray == x._rep->_isArray);
   //            getArraySize() == x.getArraySize());
   }
   
   Boolean CIMValue::isArray() const
   {
       return _rep->_isArray;
   }
   
   Boolean CIMValue::isNull() const
   {
       return _rep->_isNull;
   }
   
   Uint32 CIMValue::getArraySize() const
   {
       if (!_rep->_isArray)
           return 0;
   
       switch (_rep->_type)
       {
           case CIMTYPE_BOOLEAN:
               return _rep->_u._booleanArray->size();
                 break;                 break;
  
             case CIMType::SINT16:          case CIMTYPE_UINT8:
                 _Dec(_u._sint16Array);              return _rep->_u._uint8Array->size();
                 break;                 break;
  
             case CIMType::UINT32:          case CIMTYPE_SINT8:
                 _Dec(_u._uint32Array);              return _rep->_u._sint8Array->size();
                 break;                 break;
  
             case CIMType::SINT32:          case CIMTYPE_UINT16:
                 _Dec(_u._sint32Array);              return _rep->_u._uint16Array->size();
                 break;                 break;
  
             case CIMType::UINT64:          case CIMTYPE_SINT16:
                 _Dec(_u._uint64Array);              return _rep->_u._sint16Array->size();
                 break;                 break;
  
             case CIMType::SINT64:          case CIMTYPE_UINT32:
                 _Dec(_u._sint64Array);              return _rep->_u._uint32Array->size();
                 break;                 break;
  
             case CIMType::REAL32:          case CIMTYPE_SINT32:
                 _Dec(_u._real32Array);              return _rep->_u._sint32Array->size();
                 break;                 break;
  
             case CIMType::REAL64:          case CIMTYPE_UINT64:
                 _Dec(_u._real64Array);              return _rep->_u._uint64Array->size();
                 break;                 break;
  
             case CIMType::CHAR16:          case CIMTYPE_SINT64:
                 _Dec(_u._char16Array);              return _rep->_u._sint64Array->size();
                 break;                 break;
  
             case CIMType::STRING:          case CIMTYPE_REAL32:
                 _Dec(_u._stringArray);              return _rep->_u._real32Array->size();
                 break;                 break;
  
             case CIMType::DATETIME:          case CIMTYPE_REAL64:
                 _Dec(_u._dateTimeArray);              return _rep->_u._real64Array->size();
                 break;                 break;
         }  
     }          case CIMTYPE_CHAR16:
     else              return _rep->_u._char16Array->size();
     {  
         switch (_type)  
         {  
             case CIMType::BOOLEAN:  
             case CIMType::UINT8:  
             case CIMType::SINT8:  
             case CIMType::UINT16:  
             case CIMType::SINT16:  
             case CIMType::UINT32:  
             case CIMType::SINT32:  
             case CIMType::UINT64:  
             case CIMType::SINT64:  
             case CIMType::REAL32:  
             case CIMType::REAL64:  
             case CIMType::CHAR16:  
                 break;                 break;
  
             case CIMType::STRING:          case CIMTYPE_STRING:
                 delete _u._stringValue;              return _rep->_u._stringArray->size();
                 break;                 break;
  
             case CIMType::DATETIME:          case CIMTYPE_DATETIME:
                 delete _u._dateTimeValue;              return _rep->_u._dateTimeArray->size();
                 break;                 break;
  
             case CIMType::REFERENCE:          case CIMTYPE_REFERENCE:
                 delete _u._referenceValue;              return _rep->_u._referenceArray->size();
                 break;                 break;
         }          // Should never get here. switch on complete enum
           default:
               throw CIMValueInvalidTypeException();
     }     }
  
     _init();      // Unreachable!
       PEGASUS_ASSERT(false);
       return 0;
 } }
  
 void CIMValue::toXml(Array<Sint8>& out) const  CIMType CIMValue::getType() const
 {  
     if (_isArray)  
     {     {
         out << "<VALUE.ARRAY>\n";      return CIMType(_rep->_type);
   }
  
         switch (_type)  void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize)
         {         {
             case CIMType::BOOLEAN:      clear();
   
       if (isArray)
             {             {
                 for (Uint32 i = 0, n = _u._booleanArray->size; i < n; i++)          switch (type)
                 {                 {
                     out << "<VALUE>";              case CIMTYPE_BOOLEAN:
                     _toXml(out, Boolean(_u._booleanArray->data()[i]));                  set(Array<Boolean>(arraySize));
                     out << "</VALUE>\n";  
                 }  
                 break;                 break;
             }  
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 _toXml(out, _u._uint8Array->data(), _u._uint8Array->size);                  set(Array<Uint8>(arraySize));
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 _toXml(out, _u._sint8Array->data(), _u._sint8Array->size);                  set(Array<Sint8>(arraySize));
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 _toXml(out, _u._uint16Array->data(), _u._uint16Array->size);                  set(Array<Uint16>(arraySize));
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 _toXml(out, _u._sint16Array->data(), _u._sint16Array->size);                  set(Array<Sint16>(arraySize));
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 _toXml(out, _u._uint32Array->data(), _u._uint32Array->size);                  set(Array<Uint32>(arraySize));
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 _toXml(out, _u._sint32Array->data(), _u._sint32Array->size);                  set(Array<Sint32>(arraySize));
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 _toXml(out, _u._uint64Array->data(), _u._uint64Array->size);                  set(Array<Uint64>(arraySize));
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 _toXml(out, _u._sint64Array->data(), _u._sint64Array->size);                  set(Array<Sint64>(arraySize));
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 _toXml(out, _u._real32Array->data(), _u._real32Array->size);                  set(Array<Real32>(arraySize));
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 _toXml(out, _u._real64Array->data(), _u._real64Array->size);                  set(Array<Real64>(arraySize));
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 _toXml(out, _u._char16Array->data(), _u._char16Array->size);                  set(Array<Char16>(arraySize));
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 _toXml(out, _u._stringArray->data(), _u._stringArray->size);                  set(Array<String>(arraySize));
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 _toXml(out, _u._dateTimeArray->data(), _u._dateTimeArray->size);                  set(Array<CIMDateTime>(arraySize));
                 break;                 break;
         }  
  
         out << "</VALUE.ARRAY>\n";              case CIMTYPE_REFERENCE:
                   set(Array<CIMObjectPath>(arraySize));
                   break;
               default:
                   throw CIMValueInvalidTypeException();
     }     }
     else if (_type == CIMType::REFERENCE)  
     {  
         _u._referenceValue->toXml(out);  
     }     }
     else     else
     {     {
         out << "<VALUE>";          switch (type)
   
         switch (_type)  
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 _toXml(out, Boolean(_u._booleanValue != 0));                  set(false);
                 break;                 break;
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 _toXml(out, _u._uint8Value);                  set(Uint8(0));
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 _toXml(out, _u._sint8Value);                  set(Sint8(0));
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 _toXml(out, _u._uint16Value);                  set(Uint16(0));
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 _toXml(out, _u._sint16Value);                  set(Sint16(0));
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 _toXml(out, _u._uint32Value);                  set(Uint32(0));
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 _toXml(out, _u._sint32Value);                  set(Sint32(0));
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 _toXml(out, _u._uint64Value);                  set(Uint64(0));
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 _toXml(out, _u._sint64Value);                  set(Sint64(0));
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 _toXml(out, _u._real32Value);                  set(Real32(0.0));
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 _toXml(out, _u._real64Value);                  set(Real64(0.0));
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 _toXml(out, Char16(_u._char16Value));                  set(Char16(0));
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 _toXml(out, *_u._stringValue);                  set(String());
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 _toXml(out, *_u._dateTimeValue);                  set(CIMDateTime());
                 break;                 break;
         }  
  
         out << "</VALUE>\n";              case CIMTYPE_REFERENCE:
                   set(CIMObjectPath());
                   break;
               default:
                   throw CIMValueInvalidTypeException();
     }     }
 } }
  
 void CIMValue::print(PEGASUS_STD(ostream) &os) const      // Set the Null attribute. Note that this must be after the set
 {      // because the set functions sets the _isNull.
     Array<Sint8> tmp;  
     toXml(tmp);      _rep->_isNull = true;
     tmp.append('\0');  
     os << tmp.getData() << PEGASUS_STD(endl);  
 } }
  
 void CIMValue::set(Boolean x) void CIMValue::set(Boolean x)
 { {
     clear();     clear();
     _u._booleanValue = (Uint8)x;      _rep->_u._booleanValue = (Uint8)x;
     _type = CIMType::BOOLEAN;      _rep->_type = CIMTYPE_BOOLEAN;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(Uint8 x) void CIMValue::set(Uint8 x)
 { {
     clear();     clear();
     _u._uint8Value = x;      _rep->_u._uint8Value = x;
     _type = CIMType::UINT8;      _rep->_type = CIMTYPE_UINT8;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(Sint8 x) void CIMValue::set(Sint8 x)
 { {
     clear();     clear();
     _u._sint8Value = x;      _rep->_u._sint8Value = x;
     _type = CIMType::SINT8;      _rep->_type = CIMTYPE_SINT8;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(Uint16 x) void CIMValue::set(Uint16 x)
 { {
     clear();     clear();
     _u._uint16Value = x;      _rep->_u._uint16Value = x;
     _type = CIMType::UINT16;      _rep->_type = CIMTYPE_UINT16;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(Sint16 x) void CIMValue::set(Sint16 x)
 { {
     clear();     clear();
     _u._sint16Value = x;      _rep->_u._sint16Value = x;
     _type = CIMType::SINT16;      _rep->_type = CIMTYPE_SINT16;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(Uint32 x) void CIMValue::set(Uint32 x)
 { {
     clear();     clear();
     _u._uint32Value = x;      _rep->_u._uint32Value = x;
     _type = CIMType::UINT32;      _rep->_type = CIMTYPE_UINT32;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(Sint32 x) void CIMValue::set(Sint32 x)
 { {
     clear();     clear();
     _u._sint32Value = x;      _rep->_u._sint32Value = x;
     _type = CIMType::SINT32;      _rep->_type = CIMTYPE_SINT32;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(Uint64 x) void CIMValue::set(Uint64 x)
 { {
     clear();     clear();
     _u._uint64Value = x;      _rep->_u._uint64Value = x;
     _type = CIMType::UINT64;      _rep->_type = CIMTYPE_UINT64;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(Sint64 x) void CIMValue::set(Sint64 x)
 { {
     clear();     clear();
     _u._sint64Value = x;      _rep->_u._sint64Value = x;
     _type = CIMType::SINT64;      _rep->_type = CIMTYPE_SINT64;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(Real32 x) void CIMValue::set(Real32 x)
 { {
     clear();     clear();
     _u._real32Value = x;      _rep->_u._real32Value = x;
     _type = CIMType::REAL32;      _rep->_type = CIMTYPE_REAL32;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(Real64 x) void CIMValue::set(Real64 x)
 { {
     clear();     clear();
     _u._real64Value = x;      _rep->_u._real64Value = x;
     _type = CIMType::REAL64;      _rep->_type = CIMTYPE_REAL64;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Char16& x) void CIMValue::set(const Char16& x)
 { {
     clear();     clear();
     _u._char16Value = x;      _rep->_u._char16Value = x;
     _type = CIMType::CHAR16;      _rep->_type = CIMTYPE_CHAR16;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const String& x) void CIMValue::set(const String& x)
 { {
     clear();     clear();
     _u._stringValue = new String(x);      _rep->_u._stringValue = new String(x);
     _type = CIMType::STRING;      _rep->_type = CIMTYPE_STRING;
 }      _rep->_isNull = false;
   
 void CIMValue::set(const char* x)  
 {  
     set(String(x));  
 } }
  
 void CIMValue::set(const CIMDateTime& x) void CIMValue::set(const CIMDateTime& x)
 { {
     clear();     clear();
     _u._dateTimeValue = new CIMDateTime(x);      _rep->_u._dateTimeValue = new CIMDateTime(x);
     _type = CIMType::DATETIME;      _rep->_type = CIMTYPE_DATETIME;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const CIMReference& x)  void CIMValue::set(const CIMObjectPath& x)
 { {
     clear();     clear();
     _u._referenceValue = new CIMReference(x);      _rep->_u._referenceValue = new CIMObjectPath(x);
     _type = CIMType::REFERENCE;      _rep->_type = CIMTYPE_REFERENCE;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Boolean>& x) void CIMValue::set(const Array<Boolean>& x)
 { {
     clear();     clear();
     _Inc(_u._booleanArray = x._rep);      _rep->_u._booleanArray = new Array<Boolean>(x);
     _type = CIMType::BOOLEAN;      _rep->_type = CIMTYPE_BOOLEAN;
     _isArray = true;      _rep->_isArray = true;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Uint8>& x) void CIMValue::set(const Array<Uint8>& x)
 { {
     clear();     clear();
     _Inc(_u._uint8Array = x._rep);      _rep->_u._uint8Array = new Array<Uint8>(x);
     _type = CIMType::UINT8;      _rep->_type = CIMTYPE_UINT8;
     _isArray = true;      _rep->_isArray = true;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Sint8>& x) void CIMValue::set(const Array<Sint8>& x)
 { {
     clear();     clear();
     _Inc(_u._sint8Array = x._rep);      _rep->_u._sint8Array = new Array<Sint8>(x);
     _type = CIMType::SINT8;      _rep->_type = CIMTYPE_SINT8;
     _isArray = true;      _rep->_isArray = true;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Uint16>& x) void CIMValue::set(const Array<Uint16>& x)
 { {
     clear();     clear();
     _Inc(_u._uint16Array = x._rep);      _rep->_u._uint16Array = new Array<Uint16>(x);
     _type = CIMType::UINT16;      _rep->_type = CIMTYPE_UINT16;
     _isArray = true;      _rep->_isArray = true;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Sint16>& x) void CIMValue::set(const Array<Sint16>& x)
 { {
     clear();     clear();
     _Inc(_u._sint16Array = x._rep);      _rep->_u._sint16Array = new Array<Sint16>(x);
     _type = CIMType::SINT16;      _rep->_type = CIMTYPE_SINT16;
     _isArray = true;      _rep->_isArray = true;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Uint32>& x) void CIMValue::set(const Array<Uint32>& x)
 { {
     clear();     clear();
     _Inc(_u._uint32Array = x._rep);      _rep->_u._uint32Array = new Array<Uint32>(x);
     _type = CIMType::UINT32;      _rep->_type = CIMTYPE_UINT32;
     _isArray = true;      _rep->_isArray = true;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Sint32>& x) void CIMValue::set(const Array<Sint32>& x)
 { {
     clear();     clear();
     _Inc(_u._sint32Array = x._rep);      _rep->_u._sint32Array = new Array<Sint32>(x);
     _type = CIMType::SINT32;      _rep->_type = CIMTYPE_SINT32;
     _isArray = true;      _rep->_isArray = true;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Uint64>& x) void CIMValue::set(const Array<Uint64>& x)
 { {
     clear();     clear();
     _Inc(_u._uint64Array = x._rep);      _rep->_u._uint64Array = new Array<Uint64>(x);
     _type = CIMType::UINT64;      _rep->_type = CIMTYPE_UINT64;
     _isArray = true;      _rep->_isArray = true;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Sint64>& x) void CIMValue::set(const Array<Sint64>& x)
 { {
     clear();     clear();
     _Inc(_u._sint64Array = x._rep);      _rep->_u._sint64Array = new Array<Sint64>(x);
     _type = CIMType::SINT64;      _rep->_type = CIMTYPE_SINT64;
     _isArray = true;      _rep->_isArray = true;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Real32>& x) void CIMValue::set(const Array<Real32>& x)
 { {
     clear();     clear();
     _Inc(_u._real32Array = x._rep);      _rep->_u._real32Array = new Array<Real32>(x);
     _type = CIMType::REAL32;      _rep->_type = CIMTYPE_REAL32;
     _isArray = true;      _rep->_isArray = true;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Real64>& x) void CIMValue::set(const Array<Real64>& x)
 { {
     clear();     clear();
     _Inc(_u._real64Array = x._rep);      _rep->_u._real64Array = new Array<Real64>(x);
     _type = CIMType::REAL64;      _rep->_type = CIMTYPE_REAL64;
     _isArray = true;      _rep->_isArray = true;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<Char16>& x) void CIMValue::set(const Array<Char16>& x)
 { {
     clear();     clear();
     _Inc(_u._char16Array = x._rep);      _rep->_u._char16Array = new Array<Char16>(x);
     _type = CIMType::CHAR16;      _rep->_type = CIMTYPE_CHAR16;
     _isArray = true;      _rep->_isArray = true;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<String>& x) void CIMValue::set(const Array<String>& x)
 { {
     clear();     clear();
     _Inc(_u._stringArray = x._rep);      _rep->_u._stringArray = new Array<String>(x);
     _type = CIMType::STRING;      _rep->_type = CIMTYPE_STRING;
     _isArray = true;      _rep->_isArray = true;
       _rep->_isNull = false;
 } }
  
 void CIMValue::set(const Array<CIMDateTime>& x) void CIMValue::set(const Array<CIMDateTime>& x)
 { {
     clear();     clear();
     _Inc(_u._dateTimeArray = x._rep);      _rep->_u._dateTimeArray = new Array<CIMDateTime>(x);
     _type = CIMType::DATETIME;      _rep->_type = CIMTYPE_DATETIME;
     _isArray = true;      _rep->_isArray = true;
       _rep->_isNull = false;
   }
   
   void CIMValue::set(const Array<CIMObjectPath>& x)
   {
       clear();
       _rep->_u._referenceArray = new Array<CIMObjectPath>(x);
       _rep->_type = CIMTYPE_REFERENCE;
       _rep->_isArray = true;
       _rep->_isNull = false;
 } }
  
 void CIMValue::get(Boolean& x) const void CIMValue::get(Boolean& x) const
 { {
     if (_type != CIMType::BOOLEAN || _isArray)      if (_rep->_type != CIMTYPE_BOOLEAN || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._booleanValue != 0;      x = _rep->_u._booleanValue != 0;
 } }
  
 void CIMValue::get(Uint8& x) const void CIMValue::get(Uint8& x) const
 { {
     if (_type != CIMType::UINT8 || _isArray)      if (_rep->_type != CIMTYPE_UINT8 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._uint8Value;      x = _rep->_u._uint8Value;
 } }
  
 void CIMValue::get(Sint8& x) const void CIMValue::get(Sint8& x) const
 { {
     if (_type != CIMType::SINT8 || _isArray)      if (_rep->_type != CIMTYPE_SINT8 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._sint8Value;      x = _rep->_u._sint8Value;
 } }
  
 void CIMValue::get(Uint16& x) const void CIMValue::get(Uint16& x) const
 { {
     if (_type != CIMType::UINT16 || _isArray)      if (_rep->_type != CIMTYPE_UINT16 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._uint16Value;      x = _rep->_u._uint16Value;
 } }
  
 void CIMValue::get(Sint16& x) const void CIMValue::get(Sint16& x) const
 { {
     if (_type != CIMType::SINT16 || _isArray)      if (_rep->_type != CIMTYPE_SINT16 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._sint16Value;      x = _rep->_u._sint16Value;
 } }
  
 void CIMValue::get(Uint32& x) const void CIMValue::get(Uint32& x) const
 { {
     if (_type != CIMType::UINT32 || _isArray)      if (_rep->_type != CIMTYPE_UINT32 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._uint32Value;      x = _rep->_u._uint32Value;
 } }
  
 void CIMValue::get(Sint32& x) const void CIMValue::get(Sint32& x) const
 { {
     if (_type != CIMType::SINT32 || _isArray)      if (_rep->_type != CIMTYPE_SINT32 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._sint32Value;      x = _rep->_u._sint32Value;
 } }
  
 void CIMValue::get(Uint64& x) const void CIMValue::get(Uint64& x) const
 { {
     if (_type != CIMType::UINT64 || _isArray)      if (_rep->_type != CIMTYPE_UINT64 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._uint64Value;      x = _rep->_u._uint64Value;
 } }
  
 void CIMValue::get(Sint64& x) const void CIMValue::get(Sint64& x) const
 { {
     if (_type != CIMType::SINT64 || _isArray)      if (_rep->_type != CIMTYPE_SINT64 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._sint64Value;      x = _rep->_u._sint64Value;
 } }
  
 void CIMValue::get(Real32& x) const void CIMValue::get(Real32& x) const
 { {
     if (_type != CIMType::REAL32 || _isArray)      if (_rep->_type != CIMTYPE_REAL32 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._real32Value;      x = _rep->_u._real32Value;
 } }
  
 void CIMValue::get(Real64& x) const void CIMValue::get(Real64& x) const
 { {
     if (_type != CIMType::REAL64 || _isArray)      if (_rep->_type != CIMTYPE_REAL64 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._real64Value;      x = _rep->_u._real64Value;
 } }
  
 void CIMValue::get(Char16& x) const void CIMValue::get(Char16& x) const
 { {
     if (_type != CIMType::CHAR16 || _isArray)      if (_rep->_type != CIMTYPE_CHAR16 || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = _u._char16Value;      x = _rep->_u._char16Value;
 } }
  
 void CIMValue::get(String& x) const void CIMValue::get(String& x) const
 { {
     if (_type != CIMType::STRING || _isArray)      if (_rep->_type != CIMTYPE_STRING || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = *_u._stringValue;      x = *_rep->_u._stringValue;
 } }
  
 void CIMValue::get(CIMDateTime& x) const void CIMValue::get(CIMDateTime& x) const
 { {
     if (_type != CIMType::DATETIME || _isArray)      if (_rep->_type != CIMTYPE_DATETIME || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = *_u._dateTimeValue;      x = *_rep->_u._dateTimeValue;
 } }
  
 void CIMValue::get(CIMReference& x) const  void CIMValue::get(CIMObjectPath& x) const
 { {
     if (_type != CIMType::REFERENCE || _isArray)      if (_rep->_type != CIMTYPE_REFERENCE || _rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x = *_u._referenceValue;      x = *_rep->_u._referenceValue;
 } }
  
 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);      x = *_rep->_u._booleanArray;
 } }
  
 void CIMValue::get(Array<Uint8>& x) const void CIMValue::get(Array<Uint8>& x) const
 { {
     if (_type != CIMType::UINT8 || !_isArray)      if (_rep->_type != CIMTYPE_UINT8 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._uint8Array);      x = *_rep->_u._uint8Array;
 } }
  
 void CIMValue::get(Array<Sint8>& x) const void CIMValue::get(Array<Sint8>& x) const
 { {
     if (_type != CIMType::SINT8 || !_isArray)      if (_rep->_type != CIMTYPE_SINT8 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._sint8Array);      x = *_rep->_u._sint8Array;
 } }
  
 void CIMValue::get(Array<Uint16>& x) const void CIMValue::get(Array<Uint16>& x) const
 { {
     if (_type != CIMType::UINT16 || !_isArray)      if (_rep->_type != CIMTYPE_UINT16 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._uint16Array);      x = *_rep->_u._uint16Array;
 } }
  
 void CIMValue::get(Array<Sint16>& x) const void CIMValue::get(Array<Sint16>& x) const
 { {
     if (_type != CIMType::SINT16 || !_isArray)      if (_rep->_type != CIMTYPE_SINT16 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._sint16Array);      x = *_rep->_u._sint16Array;
 } }
  
 void CIMValue::get(Array<Uint32>& x) const void CIMValue::get(Array<Uint32>& x) const
 { {
     if (_type != CIMType::UINT32 || !_isArray)      if (_rep->_type != CIMTYPE_UINT32 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._uint32Array);      x = *_rep->_u._uint32Array;
 } }
  
 void CIMValue::get(Array<Sint32>& x) const void CIMValue::get(Array<Sint32>& x) const
 { {
     if (_type != CIMType::SINT32 || !_isArray)      if (_rep->_type != CIMTYPE_SINT32 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._sint32Array);      x = *_rep->_u._sint32Array;
 } }
  
 void CIMValue::get(Array<Uint64>& x) const void CIMValue::get(Array<Uint64>& x) const
 { {
     if (_type != CIMType::UINT64 || !_isArray)      if (_rep->_type != CIMTYPE_UINT64 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._uint64Array);      x = *_rep->_u._uint64Array;
 } }
  
 void CIMValue::get(Array<Sint64>& x) const void CIMValue::get(Array<Sint64>& x) const
 { {
     if (_type != CIMType::SINT64 || !_isArray)      if (_rep->_type != CIMTYPE_SINT64 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._sint64Array);      x = *_rep->_u._sint64Array;
 } }
  
 void CIMValue::get(Array<Real32>& x) const void CIMValue::get(Array<Real32>& x) const
 { {
     if (_type != CIMType::REAL32 || !_isArray)      if (_rep->_type != CIMTYPE_REAL32 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._real32Array);      x = *_rep->_u._real32Array;
 } }
  
 void CIMValue::get(Array<Real64>& x) const void CIMValue::get(Array<Real64>& x) const
 { {
     if (_type != CIMType::REAL64 || !_isArray)      if (_rep->_type != CIMTYPE_REAL64 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._real64Array);      x = *_rep->_u._real64Array;
 } }
  
 void CIMValue::get(Array<Char16>& x) const void CIMValue::get(Array<Char16>& x) const
 { {
     if (_type != CIMType::CHAR16 || !_isArray)      if (_rep->_type != CIMTYPE_CHAR16 || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._char16Array);      x = *_rep->_u._char16Array;
 } }
  
 void CIMValue::get(Array<String>& x) const void CIMValue::get(Array<String>& x) const
 { {
     if (_type != CIMType::STRING || !_isArray)      if (_rep->_type != CIMTYPE_STRING || !_rep->_isArray)
         throw TypeMismatch();          throw TypeMismatchException();
  
     x.set(_u._stringArray);      x = *_rep->_u._stringArray;
 } }
  
 void CIMValue::get(Array<CIMDateTime>& x) const void CIMValue::get(Array<CIMDateTime>& x) const
 { {
     if (_type != CIMType::DATETIME || !_isArray)  // ATTN-RK-20020815: Use UninitializedObjectException here if CIMValue is null?
         throw TypeMismatch();  
  
     x.set(_u._dateTimeArray);      if (_rep->_type != CIMTYPE_DATETIME || !_rep->_isArray)
           throw TypeMismatchException();
   
       x = *_rep->_u._dateTimeArray;
 } }
  
 void CIMValue::_init()  void CIMValue::get(Array<CIMObjectPath>& x) const
 { {
     _type = CIMType::NONE;      if (_rep->_type != CIMTYPE_REFERENCE || !_rep->_isArray)
     _isArray = false;          throw TypeMismatchException();
     _u._voidPtr = 0;  
       x = *_rep->_u._referenceArray;
 } }
  
 Boolean operator==(const CIMValue& x, const CIMValue& y)  Boolean CIMValue::equal(const CIMValue& x) const
 { {
     if (!x.typeCompatible(y))      if (!typeCompatible(x))
           return false;
   
       if (_rep->_isNull != x._rep->_isNull)
         return false;         return false;
  
     if (x._isArray)      if (_rep->_isArray)
     {     {
         switch (x._type)          switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 return Array<Boolean>(x._u._booleanArray) ==                  return (*_rep->_u._booleanArray) ==
                     Array<Boolean>(y._u._booleanArray);                      (*x._rep->_u._booleanArray);
   
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 return Array<Uint8>(x._u._uint8Array) ==                  return (*_rep->_u._uint8Array) ==
                     Array<Uint8>(y._u._uint8Array);                      (*x._rep->_u._uint8Array);
   
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 return Array<Sint8>(x._u._sint8Array) ==                  return (*_rep->_u._sint8Array) ==
                     Array<Sint8>(y._u._sint8Array);                      (*x._rep->_u._sint8Array);
   
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 return Array<Uint16>(x._u._uint16Array) ==                  return (*_rep->_u._uint16Array) ==
                     Array<Uint16>(y._u._uint16Array);                      (*x._rep->_u._uint16Array);
   
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 return Array<Sint16>(x._u._sint16Array) ==                  return (*_rep->_u._sint16Array) ==
                     Array<Sint16>(y._u._sint16Array);                      (*x._rep->_u._sint16Array);
   
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 return Array<Uint32>(x._u._uint32Array) ==                  return (*_rep->_u._uint32Array) ==
                     Array<Uint32>(y._u._uint32Array);                      (*x._rep->_u._uint32Array);
   
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 return Array<Sint32>(x._u._sint32Array) ==                  return (*_rep->_u._sint32Array) ==
                     Array<Sint32>(y._u._sint32Array);                      (*x._rep->_u._sint32Array);
   
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 return Array<Uint64>(x._u._uint64Array) ==                  return (*_rep->_u._uint64Array) ==
                     Array<Uint64>(y._u._uint64Array);                      (*x._rep->_u._uint64Array);
   
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 return Array<Sint64>(x._u._sint64Array) ==                  return (*_rep->_u._sint64Array) ==
                     Array<Sint64>(y._u._sint64Array);                      (*x._rep->_u._sint64Array);
   
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 return Array<Real32>(x._u._real32Array) ==                  return (*_rep->_u._real32Array) ==
                     Array<Real32>(y._u._real32Array);                      (*x._rep->_u._real32Array);
   
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 return Array<Real64>(x._u._real64Array) ==                  return (*_rep->_u._real64Array) ==
                     Array<Real64>(y._u._real64Array);                      (*x._rep->_u._real64Array);
   
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 return Array<Char16>(x._u._char16Array) ==                  return (*_rep->_u._char16Array) ==
                     Array<Char16>(y._u._char16Array);                      (*x._rep->_u._char16Array);
   
             case CIMType::STRING:              case CIMTYPE_STRING:
                 return Array<String>(x._u._stringArray) ==                  return (*_rep->_u._stringArray) ==
                     Array<String>(y._u._stringArray);                      (*x._rep->_u._stringArray);
   
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 return Array<CIMDateTime>(x._u._dateTimeArray) ==                  return (*_rep->_u._dateTimeArray) ==
                     Array<CIMDateTime>(y._u._dateTimeArray);                      (*x._rep->_u._dateTimeArray);
   
               case CIMTYPE_REFERENCE:
                   return (*_rep->_u._referenceArray) ==
                       (*x._rep->_u._referenceArray);
               default:
                   throw CIMValueInvalidTypeException();
         }         }
     }     }
     else     else
     {     {
         switch (x._type)          switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 return x._u._booleanValue == y._u._booleanValue;                  return _rep->_u._booleanValue == x._rep->_u._booleanValue;
   
               case CIMTYPE_UINT8:
                   return _rep->_u._uint8Value == x._rep->_u._uint8Value;
  
             case CIMType::UINT8:              case CIMTYPE_SINT8:
                 return x._u._uint8Value == y._u._uint8Value;                  return _rep->_u._sint8Value == x._rep->_u._sint8Value;
  
             case CIMType::SINT8:              case CIMTYPE_UINT16:
                 return x._u._sint8Value == y._u._sint8Value;                  return _rep->_u._uint16Value == x._rep->_u._uint16Value;
  
             case CIMType::UINT16:              case CIMTYPE_SINT16:
                 return x._u._uint16Value == y._u._uint16Value;                  return _rep->_u._sint16Value == x._rep->_u._sint16Value;
  
             case CIMType::SINT16:              case CIMTYPE_UINT32:
                 return x._u._sint16Value == y._u._sint16Value;                  return _rep->_u._uint32Value == x._rep->_u._uint32Value;
  
             case CIMType::UINT32:              case CIMTYPE_SINT32:
                 return x._u._uint32Value == y._u._uint32Value;                  return _rep->_u._sint32Value == x._rep->_u._sint32Value;
  
             case CIMType::SINT32:              case CIMTYPE_UINT64:
                 return x._u._sint32Value == y._u._sint32Value;                  return _rep->_u._uint64Value == x._rep->_u._uint64Value;
  
             case CIMType::UINT64:              case CIMTYPE_SINT64:
                 return x._u._uint64Value == y._u._uint64Value;                  return _rep->_u._sint64Value == x._rep->_u._sint64Value;
  
             case CIMType::SINT64:              case CIMTYPE_REAL32:
                 return x._u._sint64Value == y._u._sint64Value;                  return _rep->_u._real32Value == x._rep->_u._real32Value;
  
             case CIMType::REAL32:              case CIMTYPE_REAL64:
                 return x._u._real32Value == y._u._real32Value;                  return _rep->_u._real64Value == x._rep->_u._real64Value;
  
             case CIMType::REAL64:              case CIMTYPE_CHAR16:
                 return x._u._real64Value == y._u._real64Value;                  return _rep->_u._char16Value == x._rep->_u._char16Value;
  
             case CIMType::CHAR16:              case CIMTYPE_STRING:
                 return x._u._char16Value == y._u._char16Value;                  return String::equal(*_rep->_u._stringValue,
                                        *x._rep->_u._stringValue);
  
             case CIMType::STRING:              case CIMTYPE_DATETIME:
                 return String::equal(*x._u._stringValue, *y._u._stringValue);                  return *_rep->_u._dateTimeValue == *x._rep->_u._dateTimeValue;
  
             case CIMType::DATETIME:              case CIMTYPE_REFERENCE:
                 return *x._u._dateTimeValue == *y._u._dateTimeValue;                  return *_rep->_u._referenceValue ==
                       *x._rep->_u._referenceValue;
  
             case CIMType::REFERENCE:              default:
                 return *x._u._referenceValue == *y._u._referenceValue;                  throw CIMValueInvalidTypeException();
         }         }
     }     }
  
Line 1338 
Line 1497 
     return false;     return false;
 } }
  
 void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize)  
 {  
     clear();  
   
     if (isArray)  
     {  
         switch (type)  
         {  
             case CIMType::BOOLEAN:  
                 set(Array<Boolean>(arraySize));  
                 break;  
   
             case CIMType::UINT8:  
                 set(Array<Uint8>(arraySize));  
                 break;  
   
             case CIMType::SINT8:  
                 set(Array<Sint8>(arraySize));  
                 break;  
   
             case CIMType::UINT16:  
                 set(Array<Uint16>(arraySize));  
                 break;  
   
             case CIMType::SINT16:  
                 set(Array<Sint16>(arraySize));  
                 break;  
   
             case CIMType::UINT32:  
                 set(Array<Uint32>(arraySize));  
                 break;  
   
             case CIMType::SINT32:  
                 set(Array<Sint32>(arraySize));  
                 break;  
   
             case CIMType::UINT64:  
                 set(Array<Uint64>(arraySize));  
                 break;  
   
             case CIMType::SINT64:  
                 set(Array<Sint64>(arraySize));  
                 break;  
   
             case CIMType::REAL32:  
                 set(Array<Real32>(arraySize));  
                 break;  
   
             case CIMType::REAL64:  
                 set(Array<Real64>(arraySize));  
                 break;  
   
             case CIMType::CHAR16:  
                 set(Array<Char16>(arraySize));  
                 break;  
   
             case CIMType::STRING:  
                 set(Array<String>(arraySize));  
                 break;  
   
             case CIMType::DATETIME:  
                 set(Array<CIMDateTime>(arraySize));  
                 break;  
         }  
     }  
     else  
     {  
         switch (type)  
         {  
             case CIMType::BOOLEAN:  
                 set(false);  
                 break;  
   
             case CIMType::UINT8:  
                 set(Uint8(0));  
                 break;  
   
             case CIMType::SINT8:  
                 set(Sint8(0));  
                 break;  
   
             case CIMType::UINT16:  
                 set(Uint16(0));  
                 break;  
   
             case CIMType::SINT16:  
                 set(Sint16(0));  
                 break;  
   
             case CIMType::UINT32:  
                 set(Uint32(0));  
                 break;  
   
             case CIMType::SINT32:  
                 set(Sint32(0));  
                 break;  
   
             case CIMType::UINT64:  
                 set(Uint64(0));  
                 break;  
   
             case CIMType::SINT64:  
                 set(Sint64(0));  
                 break;  
   
             case CIMType::REAL32:  
                 set(Real32(0.0));  
                 break;  
   
             case CIMType::REAL64:  
                 set(Real64(0.0));  
                 break;  
   
             case CIMType::CHAR16:  
                 set(Char16(0));  
                 break;  
   
             case CIMType::STRING:  
                 set(String());  
                 break;  
   
             case CIMType::DATETIME:  
                 set(CIMDateTime());  
                 break;  
   
             case CIMType::REFERENCE:  
                 set(CIMReference());  
                 break;  
         }  
     }  
 }  
   
 String CIMValue::toString() const String CIMValue::toString() const
 { {
     Array<Sint8> out;     Array<Sint8> out;
  
     if (_isArray)      //ATTN: Not sure what we should do with getstring for Null CIMValues
       //Choice return empty string or exception out.
       if (_rep->_isNull)
           return String();
   
       if (_rep->_isArray)
     {     {
         switch (_type)          switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
             {             {
                 for (Uint32 i = 0, n = _u._booleanArray->size; i < n; i++)                  Uint32 size = _rep->_u._booleanArray->size();
                   for (Uint32 i = 0; i < size; i++)
                 {                 {
                     _toXml(out, Boolean(_u._booleanArray->data()[i]));                      _toString(out, Boolean(_rep->_u._booleanArray->getData()[i]));
   
                     out << " ";                     out << " ";
                 }                 }
                 break;                 break;
             }             }
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 _toStr(out, _u._uint8Array->data(), _u._uint8Array->size);                  _toString(out, _rep->_u._uint8Array->getData(),
                                  _rep->_u._uint8Array->size());
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 _toStr(out, _u._sint8Array->data(), _u._sint8Array->size);                  _toString(out, _rep->_u._sint8Array->getData(),
                                  _rep->_u._sint8Array->size());
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 _toStr(out, _u._uint16Array->data(), _u._uint16Array->size);                  _toString(out, _rep->_u._uint16Array->getData(),
                                  _rep->_u._uint16Array->size());
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 _toStr(out, _u._sint16Array->data(), _u._sint16Array->size);                  _toString(out, _rep->_u._sint16Array->getData(),
                                  _rep->_u._sint16Array->size());
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 _toStr(out, _u._uint32Array->data(), _u._uint32Array->size);                  _toString(out, _rep->_u._uint32Array->getData(),
                                  _rep->_u._uint32Array->size());
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 _toStr(out, _u._sint32Array->data(), _u._sint32Array->size);                  _toString(out, _rep->_u._sint32Array->getData(),
                                  _rep->_u._sint32Array->size());
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 _toStr(out, _u._uint64Array->data(), _u._uint64Array->size);                  _toString(out, _rep->_u._uint64Array->getData(),
                                  _rep->_u._uint64Array->size());
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 _toStr(out, _u._sint64Array->data(), _u._sint64Array->size);                  _toString(out, _rep->_u._sint64Array->getData(),
                                  _rep->_u._sint64Array->size());
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 _toStr(out, _u._real32Array->data(), _u._real32Array->size);                  _toString(out, _rep->_u._real32Array->getData(),
                                  _rep->_u._real32Array->size());
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 _toStr(out, _u._real64Array->data(), _u._real64Array->size);                  _toString(out, _rep->_u._real64Array->getData(),
                                  _rep->_u._real64Array->size());
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 _toStr(out, _u._char16Array->data(), _u._char16Array->size);                  _toString(out, _rep->_u._char16Array->getData(),
                                  _rep->_u._char16Array->size());
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 _toStr(out, _u._stringArray->data(), _u._stringArray->size);                  _toString(out, _rep->_u._stringArray->getData(),
                                  _rep->_u._stringArray->size());
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 _toStr(out, _u._dateTimeArray->data(), _u._dateTimeArray->size);                  _toString(out, _rep->_u._dateTimeArray->getData(),
                                  _rep->_u._dateTimeArray->size());
                 break;                 break;
   
               case CIMTYPE_REFERENCE:
                   _toString(out, _rep->_u._referenceArray->getData(),
                                  _rep->_u._referenceArray->size());
                   break;
   
               default:
                   throw CIMValueInvalidTypeException();
         }         }
     }     }
     else if (_type == CIMType::REFERENCE)  
     {  
         return _u._referenceValue->toString();  
     }  
     else     else
     {     {
         switch (_type)          switch (_rep->_type)
         {         {
             case CIMType::BOOLEAN:              case CIMTYPE_BOOLEAN:
                 _toXml(out, Boolean(_u._booleanValue != 0));                  _toString(out, Boolean(_rep->_u._booleanValue != 0));
                 break;                 break;
  
             case CIMType::UINT8:              case CIMTYPE_UINT8:
                 _toXml(out, _u._uint8Value);                  _toString(out, _rep->_u._uint8Value);
                 break;                 break;
  
             case CIMType::SINT8:              case CIMTYPE_SINT8:
                 _toXml(out, _u._sint8Value);                  _toString(out, _rep->_u._sint8Value);
                 break;                 break;
  
             case CIMType::UINT16:              case CIMTYPE_UINT16:
                 _toXml(out, _u._uint16Value);                  _toString(out, _rep->_u._uint16Value);
                 break;                 break;
  
             case CIMType::SINT16:              case CIMTYPE_SINT16:
                 _toXml(out, _u._sint16Value);                  _toString(out, _rep->_u._sint16Value);
                 break;                 break;
  
             case CIMType::UINT32:              case CIMTYPE_UINT32:
                 _toXml(out, _u._uint32Value);                  _toString(out, _rep->_u._uint32Value);
                 break;                 break;
  
             case CIMType::SINT32:              case CIMTYPE_SINT32:
                 _toXml(out, _u._sint32Value);                  _toString(out, _rep->_u._sint32Value);
                 break;                 break;
  
             case CIMType::UINT64:              case CIMTYPE_UINT64:
                 _toXml(out, _u._uint64Value);                  _toString(out, _rep->_u._uint64Value);
                 break;                 break;
  
             case CIMType::SINT64:              case CIMTYPE_SINT64:
                 _toXml(out, _u._sint64Value);                  _toString(out, _rep->_u._sint64Value);
                 break;                 break;
  
             case CIMType::REAL32:              case CIMTYPE_REAL32:
                 _toXml(out, _u._real32Value);                  _toString(out, _rep->_u._real32Value);
                 break;                 break;
  
             case CIMType::REAL64:              case CIMTYPE_REAL64:
                 _toXml(out, _u._real64Value);                  _toString(out, _rep->_u._real64Value);
                 break;                 break;
  
             case CIMType::CHAR16:              case CIMTYPE_CHAR16:
                 _toXml(out, Char16(_u._char16Value));                  _toString(out, Char16(_rep->_u._char16Value));
                 break;                 break;
  
             case CIMType::STRING:              case CIMTYPE_STRING:
                 _toXml(out, *_u._stringValue);                  _toString(out, *_rep->_u._stringValue);
                 break;                 break;
  
             case CIMType::DATETIME:              case CIMTYPE_DATETIME:
                 _toXml(out, *_u._dateTimeValue);                  _toString(out, *_rep->_u._dateTimeValue);
                 break;                 break;
   
               case CIMTYPE_REFERENCE:
                   _toString(out, *_rep->_u._referenceValue);
                   break;
   
               default:
                   throw CIMValueInvalidTypeException();
         }         }
     }     }
  
Line 1612 
Line 1668 
     return out.getData();     return out.getData();
 } }
  
   
   Boolean operator==(const CIMValue& x, const CIMValue& y)
   {
       return x.equal(y);
   }
   
   Boolean operator!=(const CIMValue& x, const CIMValue& y)
   {
       return !x.equal(y);
   }
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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