(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.49.4.1 and 1.75

version 1.49.4.1, 2004/11/12 17:48:28 version 1.75, 2008/12/02 09:00:46
Line 1 
Line 1 
 //%2003////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development  // Licensed to The Open Group (TOG) under one or more contributor license
 // Company, L. P., IBM Corp., The Open Group, Tivoli Systems.  // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;  // this work for additional information regarding copyright ownership.
 // IBM Corp.; EMC Corporation, The Open Group.  // Each contributor licenses this file to you under the OpenPegasus Open
   // Source License; you may not use this file except in compliance with the
   // License.
 // //
 // 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
 // of this software and associated documentation files (the "Software"), to  // copy of this software and associated documentation files (the "Software"),
 // deal in the Software without restriction, including without limitation the  // to deal in the Software without restriction, including without limitation
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // sell copies of the Software, and to permit persons to whom the Software is  // and/or sell copies of the Software, and to permit persons to whom the
 // furnished to do so, subject to the following conditions:  // Software is furnished to do so, subject to the following conditions:
 // //
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  // The above copyright notice and this permission notice shall be included
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  // in all copies or substantial portions of the Software.
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT  
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR  
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT  
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN  
 // 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.  
 // //
 //==============================================================================  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 //  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 // Author: Mike Brasher (mbrasher@bmc.com)  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 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.
 // //
 // 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)  
 //              Adriann Schuur (schuur@de.ibm.com) PEP 164  
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 37 
Line 33 
 #include <cstdio> #include <cstdio>
 #include <cctype> #include <cctype>
 #include "CIMValue.h" #include "CIMValue.h"
   #include "CIMInstance.h"
 #include "Union.h" #include "Union.h"
 #include "Indentor.h"  
 #include "XmlWriter.h" #include "XmlWriter.h"
 #include "CommonUTF.h" #include "CommonUTF.h"
   
 #include "CIMValueRep.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 50 
Line 53 
 # include "ArrayImpl.h" # include "ArrayImpl.h"
 #undef PEGASUS_ARRAY_T #undef PEGASUS_ARRAY_T
  
 ////////////////////////////////////////////////////////////////////////////////  // ATTN: By getting a CIMObject from a CIMValue, the client of CIMValue can
   // modify the internals of that CIMObject and thus change what CIMValue
   // itself refers to. There are two solutions: clone() at ever juncture or
   // force CIMValue to make its own unique copy when the client calls get()
   // to get a CIMObject.
  
   //==============================================================================
 // //
 // _toString routines:  // _toString() routines:
 // //
 ////////////////////////////////////////////////////////////////////////////////  //==============================================================================
  
 inline void _toString(Array<Sint8>& out, Boolean x)  inline void _toString(Buffer& out, Boolean x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _toString(Array<Sint8>& out, Uint8 x) { XmlWriter::append(out, Uint32(x)); }  inline void _toString(Buffer& out, Uint8 x)
 inline void _toString(Array<Sint8>& out, Sint8 x) { XmlWriter::append(out, Sint32(x)); }  
 inline void _toString(Array<Sint8>& out, Uint16 x) { XmlWriter::append(out, Uint32(x)); }  
 inline void _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); }  
   
 inline void _toString(Array<Sint8>& out, Char16 x)  
 {  
     // We need to convert the Char16 to UTF8 then append the UTF8  
     // character into the array.  
     // NOTE: The UTF8 character could be several bytes long.  
     // WARNING: This function will put in replacement character for  
     // all characters that have surogate pairs.  
   
     char str[6];  
     memset(str,0x00,sizeof(str));  
     char* charIN = (char *)&x;  
   
     const Uint16 *strsrc = (Uint16 *)charIN;  
     Uint16 *endsrc = (Uint16 *)&charIN[1];  
   
     Uint8 *strtgt = (Uint8 *)str;  
     Uint8 *endtgt = (Uint8 *)&str[5];  
   
     UTF16toUTF8(&strsrc,  
                 endsrc,  
                 &strtgt,  
                 endtgt);  
   
     out.append((Sint8 *)str, UTF_8_COUNT_TRAIL_BYTES(str[0]) +1);  
 }  
   
 inline void _toString(Array<Sint8>& out, const String& x)  
 { {
     out << x;      XmlWriter::append(out, Uint32(x));
 } }
  
 inline void _toString(Array<Sint8>& out, const CIMDateTime& x)  inline void _toString(Buffer& out, Sint8 x)
 { {
     out << x.toString();      XmlWriter::append(out, Sint32(x));
 } }
  
 inline void _toString(Array<Sint8>& out, const CIMObjectPath& x)  inline void _toString(Buffer& out, Uint16 x)
 { {
     out << x.toString();      XmlWriter::append(out, Uint32(x));
 } }
  
 inline void _toString(Array<Sint8>& out, const CIMObject& x)  inline void _toString(Buffer& out, Sint16 x)
 { {
     out << x.toString();      XmlWriter::append(out, Sint32(x));
 }  
   
 template<class T>  
 void _toString(Array<Sint8>& out, const T* p, Uint32 size)  
 {  
     while (size--)  
     {  
         _toString(out, *p++);  
         out << " ";  
     }  
 } }
  
   inline void _toString(Buffer& out, Uint32 x)
 ////////////////////////////////////////////////////////////////////////////////  
 //  
 // CIMValue  
 //  
 ////////////////////////////////////////////////////////////////////////////////  
   
 CIMValue::CIMValue()  
 {  
     _rep = new CIMValueRep();  
 }  
   
 CIMValue::CIMValue(CIMType type, Boolean isArray, Uint32 arraySize)  
 {  
     _rep = new CIMValueRep();  
     setNullValue(type, isArray, arraySize);  
 }  
   
 CIMValue::CIMValue(Boolean x)  
 {  
     _rep = new CIMValueRep();  
     set(x);  
 }  
   
 CIMValue::CIMValue(Uint8 x)  
 {  
     _rep = new CIMValueRep();  
     set(x);  
 }  
   
 CIMValue::CIMValue(Sint8 x)  
 {  
     _rep = new CIMValueRep();  
     set(x);  
 }  
   
 CIMValue::CIMValue(Uint16 x)  
 {  
     _rep = new CIMValueRep();  
     set(x);  
 }  
   
 CIMValue::CIMValue(Sint16 x)  
 {  
     _rep = new CIMValueRep();  
     set(x);  
 }  
   
 CIMValue::CIMValue(Uint32 x)  
 {  
     _rep = new CIMValueRep();  
     set(x);  
 }  
   
 CIMValue::CIMValue(Sint32 x)  
 { {
     _rep = new CIMValueRep();      XmlWriter::append(out, x);
     set(x);  
 }  
   
 CIMValue::CIMValue(Uint64 x)  
 {  
     _rep = new CIMValueRep();  
     set(x);  
 }  
   
 CIMValue::CIMValue(Sint64 x)  
 {  
     _rep = new CIMValueRep();  
     set(x);  
 }  
   
 CIMValue::CIMValue(Real32 x)  
 {  
     _rep = new CIMValueRep();  
     set(x);  
 }  
   
 CIMValue::CIMValue(Real64 x)  
 {  
     _rep = new CIMValueRep();  
     set(x);  
 }  
   
 CIMValue::CIMValue(const Char16& x)  
 {  
     _rep = new CIMValueRep();  
     set(x);  
 }  
   
 CIMValue::CIMValue(const String& x)  
 {  
     _rep = new CIMValueRep();  
     set(x);  
 }  
   
 CIMValue::CIMValue(const CIMDateTime& x)  
 {  
     _rep = new CIMValueRep();  
     set(x);  
 } }
  
 CIMValue::CIMValue(const CIMObjectPath& x)  inline void _toString(Buffer& out, Sint32 x)
 { {
     _rep = new CIMValueRep();      XmlWriter::append(out, x);
     set(x);  
 }  
   
 CIMValue::CIMValue(const CIMObject& x)  
 {  
     _rep = new CIMValueRep();  
     set(x);  
 } }
  
 CIMValue::CIMValue(const Array<Boolean>& x)  inline void _toString(Buffer& out, Uint64 x)
 { {
     _rep = new CIMValueRep();      XmlWriter::append(out, x);
     set(x);  
 } }
  
 CIMValue::CIMValue(const Array<Uint8>& x)  inline void _toString(Buffer& out, Sint64 x)
 { {
     _rep = new CIMValueRep();      XmlWriter::append(out, x);
     set(x);  
 } }
  
 CIMValue::CIMValue(const Array<Sint8>& x)  inline void _toString(Buffer& out, Real32 x)
 { {
     _rep = new CIMValueRep();      XmlWriter::append(out, Real64(x));
     set(x);  
 } }
  
 CIMValue::CIMValue(const Array<Uint16>& x)  inline void _toString(Buffer& out, Real64 x)
 { {
     _rep = new CIMValueRep();      XmlWriter::append(out, x);
     set(x);  
 } }
  
 CIMValue::CIMValue(const Array<Sint16>& x)  inline void _toString(Buffer& out, Char16 x)
 { {
     _rep = new CIMValueRep();      // We need to convert the Char16 to UTF8 then append the UTF8
     set(x);      // character into the array.
 }      // NOTE: The UTF8 character could be several bytes long.
       // WARNING: This function will put in replacement character for
       // all characters that have surogate pairs.
  
 CIMValue::CIMValue(const Array<Uint32>& x)      char str[6];
 {      memset(str,0x00,sizeof(str));
     _rep = new CIMValueRep();      char* charIN = (char *)&x;
     set(x);  
 }  
  
 CIMValue::CIMValue(const Array<Sint32>& x)      const Uint16 *strsrc = (Uint16 *)charIN;
 {      Uint16 *endsrc = (Uint16 *)&charIN[1];
     _rep = new CIMValueRep();  
     set(x);  
 }  
  
 CIMValue::CIMValue(const Array<Uint64>& x)      Uint8 *strtgt = (Uint8 *)str;
 {      Uint8 *endtgt = (Uint8 *)&str[5];
     _rep = new CIMValueRep();  
     set(x);  
 }  
  
 CIMValue::CIMValue(const Array<Sint64>& x)      UTF16toUTF8(&strsrc, endsrc, &strtgt, endtgt);
 {      out.append(str, UTF_8_COUNT_TRAIL_BYTES(str[0]) +1);
     _rep = new CIMValueRep();  
     set(x);  
 } }
  
 CIMValue::CIMValue(const Array<Real32>& x)  inline void _toString(Buffer& out, const String& x)
 { {
     _rep = new CIMValueRep();      out << x;
     set(x);  
 } }
  
 CIMValue::CIMValue(const Array<Real64>& x)  inline void _toString(Buffer& out, const CIMDateTime& x)
 { {
     _rep = new CIMValueRep();      out << x.toString();
     set(x);  
 } }
  
 CIMValue::CIMValue(const Array<Char16>& x)  inline void _toString(Buffer& out, const CIMObjectPath& x)
 { {
     _rep = new CIMValueRep();      out << x.toString();
     set(x);  
 } }
  
 CIMValue::CIMValue(const Array<String>& x)  inline void _toString(Buffer& out, const CIMObject& x)
 { {
     _rep = new CIMValueRep();      out << x.toString();
     set(x);  
 } }
   inline void _toString(Buffer& out, const CIMInstance& x)
 CIMValue::CIMValue(const Array<CIMDateTime>& x)  
 { {
     _rep = new CIMValueRep();      out << CIMObject(x).toString();
     set(x);  
 } }
  
 CIMValue::CIMValue(const Array<CIMObjectPath>& x)  template<class T>
   void _toString(Buffer& out, const T* p, Uint32 size)
 { {
     _rep = new CIMValueRep();      while (size--)
     set(x);  
 }  
   
 CIMValue::CIMValue(const Array<CIMObject>& x)  
 { {
     _rep = new CIMValueRep();          _toString(out, *p++);
     set(x);          out.append(' ');
 } }
   
 CIMValue::CIMValue(const CIMValue& x)  
 {  
     _rep = new CIMValueRep();  
     assign(x);  
 } }
  
 CIMValue::~CIMValue()  //==============================================================================
 {  //
     clear();  // CIMValueRep
     delete _rep;  //
 }  //==============================================================================
  
 CIMValue& CIMValue::operator=(const CIMValue& x)  CIMValueRep CIMValueRep::_emptyRep((int*)0);
 {  
     assign(x);  
     return *this;  
 }  
  
 void CIMValue::assign(const CIMValue& x)  void CIMValueRep::release()
 { {
     if (this == &x)      if (isArray)
         return;  
   
     clear();  
   
     _rep->_type = x._rep->_type;  
     _rep->_isArray = x._rep->_isArray;  
     _rep->_isNull = x._rep->_isNull;  
   
     if (_rep->_isArray)  
     {     {
         switch (_rep->_type)          switch (type)
         {         {
             case CIMTYPE_BOOLEAN:             case CIMTYPE_BOOLEAN:
                 _rep->_u._booleanArray =                  CIMValueType<Boolean>::destructArray(this);
                     new Array<Boolean>(*(x._rep->_u._booleanArray));  
                 break;                 break;
  
             case CIMTYPE_UINT8:             case CIMTYPE_UINT8:
                 _rep->_u._uint8Array =                  CIMValueType<Uint8>::destructArray(this);
                     new Array<Uint8>(*(x._rep->_u._uint8Array));  
                 break;                 break;
  
             case CIMTYPE_SINT8:             case CIMTYPE_SINT8:
                 _rep->_u._sint8Array =                  CIMValueType<Sint8>::destructArray(this);
                     new Array<Sint8>(*(x._rep->_u._sint8Array));  
                 break;                 break;
  
             case CIMTYPE_UINT16:             case CIMTYPE_UINT16:
                 _rep->_u._uint16Array =                  CIMValueType<Uint16>::destructArray(this);
                     new Array<Uint16>(*(x._rep->_u._uint16Array));  
                 break;                 break;
  
             case CIMTYPE_SINT16:             case CIMTYPE_SINT16:
                 _rep->_u._sint16Array =                  CIMValueType<Sint16>::destructArray(this);
                     new Array<Sint16>(*(x._rep->_u._sint16Array));  
                 break;                 break;
  
             case CIMTYPE_UINT32:             case CIMTYPE_UINT32:
                 _rep->_u._uint32Array =                  CIMValueType<Uint32>::destructArray(this);
                     new Array<Uint32>(*(x._rep->_u._uint32Array));  
                 break;                 break;
  
             case CIMTYPE_SINT32:             case CIMTYPE_SINT32:
                 _rep->_u._sint32Array =                  CIMValueType<Sint32>::destructArray(this);
                     new Array<Sint32>(*(x._rep->_u._sint32Array));  
                 break;                 break;
  
             case CIMTYPE_UINT64:             case CIMTYPE_UINT64:
                 _rep->_u._uint64Array =                  CIMValueType<Uint64>::destructArray(this);
                     new Array<Uint64>(*(x._rep->_u._uint64Array));  
                 break;                 break;
  
             case CIMTYPE_SINT64:             case CIMTYPE_SINT64:
                 _rep->_u._sint64Array =                  CIMValueType<Sint64>::destructArray(this);
                     new Array<Sint64>(*(x._rep->_u._sint64Array));  
                 break;                 break;
  
             case CIMTYPE_REAL32:             case CIMTYPE_REAL32:
                 _rep->_u._real32Array =                  CIMValueType<Real32>::destructArray(this);
                     new Array<Real32>(*(x._rep->_u._real32Array));  
                 break;                 break;
  
             case CIMTYPE_REAL64:             case CIMTYPE_REAL64:
                 _rep->_u._real64Array =                  CIMValueType<Real64>::destructArray(this);
                     new Array<Real64>(*(x._rep->_u._real64Array));  
                 break;                 break;
  
             case CIMTYPE_CHAR16:             case CIMTYPE_CHAR16:
                 _rep->_u._char16Array =                  CIMValueType<Char16>::destructArray(this);
                     new Array<Char16>(*(x._rep->_u._char16Array));  
                 break;                 break;
  
             case CIMTYPE_STRING:             case CIMTYPE_STRING:
                 _rep->_u._stringArray =                  CIMValueType<String>::destructArray(this);
                     new Array<String>(*(x._rep->_u._stringArray));  
                 break;                 break;
  
             case CIMTYPE_DATETIME:             case CIMTYPE_DATETIME:
                 _rep->_u._dateTimeArray =                  CIMValueType<CIMDateTime>::destructArray(this);
                     new Array<CIMDateTime>(*(x._rep->_u._dateTimeArray));  
                 break;                 break;
  
             case CIMTYPE_REFERENCE:             case CIMTYPE_REFERENCE:
                 _rep->_u._referenceArray =                  CIMValueType<CIMObjectPath>::destructArray(this);
                     new Array<CIMObjectPath>(*(x._rep->_u._referenceArray));  
                 break;                 break;
  
         case CIMTYPE_OBJECT:         case CIMTYPE_OBJECT:
                 _rep->_u._cimobjectArray =                  CIMValueType<CIMObject>::destructArray(this);
                     new Array<CIMObject>(*(x._rep->_u._cimobjectArray));                  break;
               case CIMTYPE_INSTANCE:
                   CIMValueType<CIMInstance>::destructArray(this);
                 break;                 break;
   
             default:  
                 PEGASUS_ASSERT(false);  
         }         }
     }     }
     else     else
     {     {
         switch (_rep->_type)          switch (type)
         {         {
             case CIMTYPE_BOOLEAN:             case CIMTYPE_BOOLEAN:
                 _rep->_u._booleanValue = x._rep->_u._booleanValue;  
                 break;  
   
             case CIMTYPE_UINT8:             case CIMTYPE_UINT8:
                 _rep->_u._uint8Value = x._rep->_u._uint8Value;  
                 break;  
   
             case CIMTYPE_SINT8:             case CIMTYPE_SINT8:
                 _rep->_u._sint8Value = x._rep->_u._sint8Value;  
                 break;  
   
             case CIMTYPE_UINT16:             case CIMTYPE_UINT16:
                 _rep->_u._uint16Value = x._rep->_u._uint16Value;  
                 break;  
   
             case CIMTYPE_SINT16:             case CIMTYPE_SINT16:
                 _rep->_u._sint16Value = x._rep->_u._sint16Value;  
                 break;  
   
             case CIMTYPE_UINT32:             case CIMTYPE_UINT32:
                 _rep->_u._uint32Value = x._rep->_u._uint32Value;  
                 break;  
   
             case CIMTYPE_SINT32:             case CIMTYPE_SINT32:
                 _rep->_u._sint32Value = x._rep->_u._sint32Value;  
                 break;  
   
             case CIMTYPE_UINT64:             case CIMTYPE_UINT64:
                 _rep->_u._uint64Value = x._rep->_u._uint64Value;  
                 break;  
   
             case CIMTYPE_SINT64:             case CIMTYPE_SINT64:
                 _rep->_u._sint64Value = x._rep->_u._sint64Value;  
                 break;  
   
             case CIMTYPE_REAL32:             case CIMTYPE_REAL32:
                 _rep->_u._real32Value = x._rep->_u._real32Value;  
                 break;  
   
             case CIMTYPE_REAL64:             case CIMTYPE_REAL64:
                 _rep->_u._real64Value = x._rep->_u._real64Value;  
                 break;  
   
             case CIMTYPE_CHAR16:             case CIMTYPE_CHAR16:
                 _rep->_u._char16Value = x._rep->_u._char16Value;  
                 break;                 break;
  
             case CIMTYPE_STRING:             case CIMTYPE_STRING:
                 _rep->_u._stringValue = new String(*(x._rep->_u._stringValue));                  CIMValueType<String>::destruct(this);
                 break;                 break;
  
             case CIMTYPE_DATETIME:             case CIMTYPE_DATETIME:
                 _rep->_u._dateTimeValue =                  CIMValueType<CIMDateTime>::destruct(this);
                     new CIMDateTime(*(x._rep->_u._dateTimeValue));  
                 break;                 break;
  
             case CIMTYPE_REFERENCE:             case CIMTYPE_REFERENCE:
                 _rep->_u._referenceValue =                  CIMValueType<CIMObjectPath>::destruct(this);
                     new CIMObjectPath(*(x._rep->_u._referenceValue));  
                 break;                 break;
  
             case CIMTYPE_OBJECT:             case CIMTYPE_OBJECT:
                 _rep->_u._cimobjectValue =                  CIMValueType<CIMObject>::destruct(this);
                     new CIMObject(x._rep->_u._cimobjectValue->clone());                  break;
               case CIMTYPE_INSTANCE:
                   CIMValueType<CIMInstance>::destruct(this);
                 break;                 break;
   
             // Should never get here. testing complete enum  
             default:  
                 PEGASUS_ASSERT(false);  
         }         }
     }     }
 } }
  
 void CIMValue::clear()  //==============================================================================
   //
   // CIMValue
   //
   //==============================================================================
   
   static inline void _release(CIMValueRep*& rep)
   {
       if (rep->refs.get() == 1)
           rep->release();
       else
 { {
     if (_rep->_isArray)          CIMValueRep::unref(rep);
           rep = new CIMValueRep;
       }
   }
   
   CIMValue::CIMValue(CIMType type, Boolean isArray, Uint32 arraySize)
     {     {
         switch (_rep->_type)      _rep = new CIMValueRep;
   
       switch (type)
         {         {
             case CIMTYPE_BOOLEAN:             case CIMTYPE_BOOLEAN:
                 delete _rep->_u._booleanArray;              CIMValueType<Boolean>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_UINT8:             case CIMTYPE_UINT8:
                 delete _rep->_u._uint8Array;              CIMValueType<Uint8>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_SINT8:             case CIMTYPE_SINT8:
                 delete _rep->_u._sint8Array;              CIMValueType<Sint8>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_UINT16:             case CIMTYPE_UINT16:
                 delete _rep->_u._uint16Array;              CIMValueType<Uint16>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_SINT16:             case CIMTYPE_SINT16:
                 delete _rep->_u._sint16Array;              CIMValueType<Sint16>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_UINT32:             case CIMTYPE_UINT32:
                 delete _rep->_u._uint32Array;              CIMValueType<Uint32>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_SINT32:             case CIMTYPE_SINT32:
                 delete _rep->_u._sint32Array;              CIMValueType<Sint32>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_UINT64:             case CIMTYPE_UINT64:
                 delete _rep->_u._uint64Array;              CIMValueType<Uint64>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_SINT64:             case CIMTYPE_SINT64:
                 delete _rep->_u._sint64Array;              CIMValueType<Sint64>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_REAL32:             case CIMTYPE_REAL32:
                 delete _rep->_u._real32Array;              CIMValueType<Real32>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_REAL64:             case CIMTYPE_REAL64:
                 delete _rep->_u._real64Array;              CIMValueType<Real64>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_CHAR16:             case CIMTYPE_CHAR16:
                 delete _rep->_u._char16Array;              CIMValueType<Char16>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_STRING:             case CIMTYPE_STRING:
                 delete _rep->_u._stringArray;              CIMValueType<String>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_DATETIME:             case CIMTYPE_DATETIME:
                 delete _rep->_u._dateTimeArray;              CIMValueType<CIMDateTime>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_REFERENCE:             case CIMTYPE_REFERENCE:
                 delete _rep->_u._referenceArray;              CIMValueType<CIMObjectPath>::setNull(_rep, type, isArray,arraySize);
                 break;                 break;
  
             case CIMTYPE_OBJECT:             case CIMTYPE_OBJECT:
                 delete _rep->_u._cimobjectArray;              CIMValueType<CIMObject>::setNull(_rep, type, isArray, arraySize);
               break;
           case CIMTYPE_INSTANCE:
               CIMValueType<CIMInstance>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             default:             default:
                 PEGASUS_ASSERT(false);              PEGASUS_ASSERT(0);
         }         }
     }     }
     else  
   CIMValue::CIMValue(Boolean x)
     {     {
         switch (_rep->_type)      _rep = new CIMValueRep;
       CIMValueType<Boolean>::set(_rep, x);
   }
   
   CIMValue::CIMValue(Uint8 x)
         {         {
             case CIMTYPE_BOOLEAN:      _rep = new CIMValueRep;
             case CIMTYPE_UINT8:      CIMValueType<Uint8>::set(_rep, x);
             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:  CIMValue::CIMValue(Sint8 x)
                 delete _rep->_u._stringValue;  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Sint8>::set(_rep, x);
   }
  
             case CIMTYPE_DATETIME:  CIMValue::CIMValue(Uint16 x)
                 delete _rep->_u._dateTimeValue;  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Uint16>::set(_rep, x);
   }
  
             case CIMTYPE_REFERENCE:  CIMValue::CIMValue(Sint16 x)
                 delete _rep->_u._referenceValue;  {
                 break;      _rep = new CIMValueRep;
       CIMValueType<Sint16>::set(_rep, x);
   }
   
   CIMValue::CIMValue(Uint32 x)
   {
       _rep = new CIMValueRep;
       CIMValueType<Uint32>::set(_rep, x);
   }
   
   CIMValue::CIMValue(Sint32 x)
   {
       _rep = new CIMValueRep;
       CIMValueType<Sint32>::set(_rep, x);
   }
   
   CIMValue::CIMValue(Uint64 x)
   {
       _rep = new CIMValueRep;
       CIMValueType<Uint64>::set(_rep, x);
   }
   
   CIMValue::CIMValue(Sint64 x)
   {
       _rep = new CIMValueRep;
       CIMValueType<Sint64>::set(_rep, x);
   }
   
   CIMValue::CIMValue(Real32 x)
   {
       _rep = new CIMValueRep;
       CIMValueType<Real32>::set(_rep, x);
   }
   
   CIMValue::CIMValue(Real64 x)
   {
       _rep = new CIMValueRep;
       CIMValueType<Real64>::set(_rep, x);
   }
   
   CIMValue::CIMValue(const Char16& x)
   {
       _rep = new CIMValueRep;
       CIMValueType<Char16>::set(_rep, x);
   }
   
   CIMValue::CIMValue(const String& x)
   {
       _rep = new CIMValueRep;
       CIMValueType<String>::set(_rep, x);
   }
   
   CIMValue::CIMValue(const CIMDateTime& x)
   {
       _rep = new CIMValueRep;
       CIMValueType<CIMDateTime>::set(_rep, x);
   }
   
   CIMValue::CIMValue(const CIMObjectPath& x)
   {
       _rep = new CIMValueRep;
       CIMValueType<CIMObjectPath>::set(_rep, x);
   }
  
             case CIMTYPE_OBJECT:  CIMValue::CIMValue(const CIMObject& x)
                 delete _rep->_u._cimobjectValue;  {
                 break;      if (x.isUninitialized())
       {
           // Bug 3373, throw exception if uninitialized object is passed to set().
           throw UninitializedObjectException();
       }
  
             default:      _rep = new CIMValueRep;
                 PEGASUS_ASSERT(false);      CIMValueType<CIMObject>::set(_rep, x.clone());
         }         }
   CIMValue::CIMValue(const CIMInstance& x)
   {
       if (x.isUninitialized())
       {
           // Bug 3373, throw exception if uninitialized object is passed to set().
           throw UninitializedObjectException();
     }     }
  
     _rep->reset();      _rep = new CIMValueRep;
       CIMValueType<CIMInstance>::set(_rep, x.clone());
   }
   CIMValue::CIMValue(const Array<Boolean>& x)
   {
       _rep = new CIMValueRep;
       CIMValueType<Boolean>::setArray(_rep, x);
 } }
  
 Boolean CIMValue::typeCompatible(const CIMValue& x) const  CIMValue::CIMValue(const Array<Uint8>& x)
 { {
     return (_rep->_type == x._rep->_type &&      _rep = new CIMValueRep;
             _rep->_isArray == x._rep->_isArray);      CIMValueType<Uint8>::setArray(_rep, x);
 //            getArraySize() == x.getArraySize());  
 } }
  
 Boolean CIMValue::isArray() const  CIMValue::CIMValue(const Array<Sint8>& x)
 { {
     return _rep->_isArray;      _rep = new CIMValueRep;
       CIMValueType<Sint8>::setArray(_rep, x);
 } }
  
 Boolean CIMValue::isNull() const  CIMValue::CIMValue(const Array<Uint16>& x)
 { {
     return _rep->_isNull;      _rep = new CIMValueRep;
       CIMValueType<Uint16>::setArray(_rep, x);
 } }
  
 Uint32 CIMValue::getArraySize() const  CIMValue::CIMValue(const Array<Sint16>& x)
 { {
     if (!_rep->_isArray)      _rep = new CIMValueRep;
         return 0;      CIMValueType<Sint16>::setArray(_rep, x);
   }
  
     switch (_rep->_type)  CIMValue::CIMValue(const Array<Uint32>& x)
     {     {
         case CIMTYPE_BOOLEAN:      _rep = new CIMValueRep;
             return _rep->_u._booleanArray->size();      CIMValueType<Uint32>::setArray(_rep, x);
             break;  }
  
         case CIMTYPE_UINT8:  CIMValue::CIMValue(const Array<Sint32>& x)
             return _rep->_u._uint8Array->size();  {
             break;      _rep = new CIMValueRep;
       CIMValueType<Sint32>::setArray(_rep, x);
   }
  
         case CIMTYPE_SINT8:  CIMValue::CIMValue(const Array<Uint64>& x)
             return _rep->_u._sint8Array->size();  {
             break;      _rep = new CIMValueRep;
       CIMValueType<Uint64>::setArray(_rep, x);
   }
  
         case CIMTYPE_UINT16:  CIMValue::CIMValue(const Array<Sint64>& x)
             return _rep->_u._uint16Array->size();  {
             break;      _rep = new CIMValueRep;
       CIMValueType<Sint64>::setArray(_rep, x);
   }
  
         case CIMTYPE_SINT16:  CIMValue::CIMValue(const Array<Real32>& x)
             return _rep->_u._sint16Array->size();  {
             break;      _rep = new CIMValueRep;
       CIMValueType<Real32>::setArray(_rep, x);
   }
  
         case CIMTYPE_UINT32:  CIMValue::CIMValue(const Array<Real64>& x)
             return _rep->_u._uint32Array->size();  {
             break;      _rep = new CIMValueRep;
       CIMValueType<Real64>::setArray(_rep, x);
   }
  
         case CIMTYPE_SINT32:  CIMValue::CIMValue(const Array<Char16>& x)
             return _rep->_u._sint32Array->size();  {
             break;      _rep = new CIMValueRep;
       CIMValueType<Char16>::setArray(_rep, x);
   }
  
         case CIMTYPE_UINT64:  CIMValue::CIMValue(const Array<String>& x)
             return _rep->_u._uint64Array->size();  {
             break;      _rep = new CIMValueRep;
       CIMValueType<String>::setArray(_rep, x);
   }
  
         case CIMTYPE_SINT64:  CIMValue::CIMValue(const Array<CIMDateTime>& x)
             return _rep->_u._sint64Array->size();  {
             break;      _rep = new CIMValueRep;
       CIMValueType<CIMDateTime>::setArray(_rep, x);
   }
  
         case CIMTYPE_REAL32:  CIMValue::CIMValue(const Array<CIMObjectPath>& x)
             return _rep->_u._real32Array->size();  {
             break;      _rep = new CIMValueRep;
       CIMValueType<CIMObjectPath>::setArray(_rep, x);
   }
  
         case CIMTYPE_REAL64:  CIMValue::CIMValue(const Array<CIMObject>& x)
             return _rep->_u._real64Array->size();  {
             break;      Array<CIMObject> tmp;
  
         case CIMTYPE_CHAR16:      for (Uint32 i = 0, n = x.size(); i < n; i++)
             return _rep->_u._char16Array->size();      {
             break;          if (x[i].isUninitialized())
           {
               // Bug 3373, throw exception on uninitialized object.
               _rep = &CIMValueRep::_emptyRep;
               throw UninitializedObjectException();
           }
  
         case CIMTYPE_STRING:          tmp.append(x[i].clone());
             return _rep->_u._stringArray->size();      }
             break;  
  
         case CIMTYPE_DATETIME:      _rep = new CIMValueRep;
             return _rep->_u._dateTimeArray->size();      CIMValueType<CIMObject>::setArray(_rep, tmp);
             break;  }
  
         case CIMTYPE_REFERENCE:  CIMValue::CIMValue(const Array<CIMInstance>& x)
             return _rep->_u._referenceArray->size();  {
             break;      Array<CIMInstance> tmp;
  
         case CIMTYPE_OBJECT:      for (Uint32 i = 0, n = x.size(); i < n; i++)
             return _rep->_u._cimobjectArray->size();      {
             break;          if (x[i].isUninitialized())
           {
             // Bug 3373, throw exception on uninitialized object.
             _rep = &CIMValueRep::_emptyRep;
             throw UninitializedObjectException();
           }
  
         //default:  // Handled below          tmp.append(x[i].clone());
       }
       _rep = new CIMValueRep;
       CIMValueType<CIMInstance>::setArray(_rep, tmp);
     }     }
  
     // Unreachable!  void CIMValue::clear()
     PEGASUS_ASSERT(false);  {
     return 0;      CIMValueRep::unref(_rep);
       _rep = &CIMValueRep::_emptyRep;
 } }
  
 CIMType CIMValue::getType() const  CIMValue& CIMValue::operator=(const CIMValue& x)
   {
       if (_rep != x._rep)
 { {
     return CIMType(_rep->_type);          CIMValueRep::unref(_rep);
           CIMValueRep::ref(_rep = x._rep);
 } }
  
 void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize)      return *this;
   }
   
   void CIMValue::assign(const CIMValue& x)
   {
       if (_rep != x._rep)
 { {
     clear();          CIMValueRep::unref(_rep);
           CIMValueRep::ref(_rep = x._rep);
       }
   }
  
     if (isArray)  Boolean CIMValue::typeCompatible(const CIMValue& x) const
     {     {
         switch (type)      return (_rep->type == x._rep->type && _rep->isArray == x._rep->isArray);
   }
   
   Uint32 CIMValue::getArraySize() const
   {
       if (!_rep->isArray)
           return 0;
   
       switch (_rep->type)
         {         {
             case CIMTYPE_BOOLEAN:             case CIMTYPE_BOOLEAN:
                 set(Array<Boolean>(arraySize));              return CIMValueType<Boolean>::arraySize(_rep);
                 break;  
  
             case CIMTYPE_UINT8:             case CIMTYPE_UINT8:
                 set(Array<Uint8>(arraySize));              return CIMValueType<Uint8>::arraySize(_rep);
                 break;  
  
             case CIMTYPE_SINT8:             case CIMTYPE_SINT8:
                 set(Array<Sint8>(arraySize));              return CIMValueType<Sint8>::arraySize(_rep);
                 break;  
  
             case CIMTYPE_UINT16:             case CIMTYPE_UINT16:
                 set(Array<Uint16>(arraySize));              return CIMValueType<Uint16>::arraySize(_rep);
                 break;  
  
             case CIMTYPE_SINT16:             case CIMTYPE_SINT16:
                 set(Array<Sint16>(arraySize));              return CIMValueType<Sint16>::arraySize(_rep);
                 break;  
  
             case CIMTYPE_UINT32:             case CIMTYPE_UINT32:
                 set(Array<Uint32>(arraySize));              return CIMValueType<Uint32>::arraySize(_rep);
                 break;  
  
             case CIMTYPE_SINT32:             case CIMTYPE_SINT32:
                 set(Array<Sint32>(arraySize));              return CIMValueType<Sint32>::arraySize(_rep);
                 break;  
  
             case CIMTYPE_UINT64:             case CIMTYPE_UINT64:
                 set(Array<Uint64>(arraySize));              return CIMValueType<Uint64>::arraySize(_rep);
                 break;  
  
             case CIMTYPE_SINT64:             case CIMTYPE_SINT64:
                 set(Array<Sint64>(arraySize));              return CIMValueType<Sint64>::arraySize(_rep);
                 break;  
  
             case CIMTYPE_REAL32:             case CIMTYPE_REAL32:
                 set(Array<Real32>(arraySize));              return CIMValueType<Real32>::arraySize(_rep);
                 break;  
  
             case CIMTYPE_REAL64:             case CIMTYPE_REAL64:
                 set(Array<Real64>(arraySize));              return CIMValueType<Real64>::arraySize(_rep);
                 break;  
  
             case CIMTYPE_CHAR16:             case CIMTYPE_CHAR16:
                 set(Array<Char16>(arraySize));              return CIMValueType<Char16>::arraySize(_rep);
                 break;  
  
             case CIMTYPE_STRING:             case CIMTYPE_STRING:
                 set(Array<String>(arraySize));              return CIMValueType<String>::arraySize(_rep);
                 break;  
  
             case CIMTYPE_DATETIME:             case CIMTYPE_DATETIME:
                 set(Array<CIMDateTime>(arraySize));              return CIMValueType<CIMDateTime>::arraySize(_rep);
                 break;  
  
             case CIMTYPE_REFERENCE:             case CIMTYPE_REFERENCE:
                 set(Array<CIMObjectPath>(arraySize));              return CIMValueType<CIMObjectPath>::arraySize(_rep);
                 break;  
  
             case CIMTYPE_OBJECT:             case CIMTYPE_OBJECT:
                 set(Array<CIMObject>(arraySize));              return CIMValueType<CIMObject>::arraySize(_rep);
                 break;          case CIMTYPE_INSTANCE:
           return CIMValueType<CIMInstance>::arraySize(_rep);
             default:             default:
                 throw TypeMismatchException();              PEGASUS_ASSERT(0);
         }         }
   
       return 0;
     }     }
     else  
   void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize)
     {     {
       //
       // Release any memory:
       //
   
       _release(_rep);
   
       //
       // Set the null value:
       //
   
         switch (type)         switch (type)
         {         {
             case CIMTYPE_BOOLEAN:             case CIMTYPE_BOOLEAN:
                 set(false);              CIMValueType<Boolean>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_UINT8:             case CIMTYPE_UINT8:
                 set(Uint8(0));              CIMValueType<Uint8>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_SINT8:             case CIMTYPE_SINT8:
                 set(Sint8(0));              CIMValueType<Sint8>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_UINT16:             case CIMTYPE_UINT16:
                 set(Uint16(0));              CIMValueType<Uint16>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_SINT16:             case CIMTYPE_SINT16:
                 set(Sint16(0));              CIMValueType<Sint16>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_UINT32:             case CIMTYPE_UINT32:
                 set(Uint32(0));              CIMValueType<Uint32>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_SINT32:             case CIMTYPE_SINT32:
                 set(Sint32(0));              CIMValueType<Sint32>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_UINT64:             case CIMTYPE_UINT64:
                 set(Uint64(0));              CIMValueType<Uint64>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_SINT64:             case CIMTYPE_SINT64:
                 set(Sint64(0));              CIMValueType<Sint64>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_REAL32:             case CIMTYPE_REAL32:
                 set(Real32(0.0));              CIMValueType<Real32>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_REAL64:             case CIMTYPE_REAL64:
                 set(Real64(0.0));              CIMValueType<Real64>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_CHAR16:             case CIMTYPE_CHAR16:
                 set(Char16(0));              CIMValueType<Char16>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_STRING:             case CIMTYPE_STRING:
                 set(String());              CIMValueType<String>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_DATETIME:             case CIMTYPE_DATETIME:
                 set(CIMDateTime());              CIMValueType<CIMDateTime>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
  
             case CIMTYPE_REFERENCE:             case CIMTYPE_REFERENCE:
                 set(CIMObjectPath());              CIMValueType<CIMObjectPath>::setNull(_rep, type, isArray,arraySize);
                 break;                 break;
  
             case CIMTYPE_OBJECT:             case CIMTYPE_OBJECT:
                 set(CIMObject());              CIMValueType<CIMObject>::setNull(_rep, type, isArray, arraySize);
               break;
           case CIMTYPE_INSTANCE:
               CIMValueType<CIMInstance>::setNull(_rep, type, isArray, arraySize);
                 break;                 break;
   
             default:             default:
                 throw TypeMismatchException();              PEGASUS_ASSERT(0);
         }         }
     }     }
  
     // Set the Null attribute. Note that this must be after the set  
     // because the set functions sets the _isNull.  
   
     _rep->_isNull = true;  
 }  
   
 void CIMValue::set(Boolean x) void CIMValue::set(Boolean x)
 { {
     clear();      _release(_rep);
     _rep->_u._booleanValue = (Uint8)x;      CIMValueType<Boolean>::set(_rep, x);
     _rep->_type = CIMTYPE_BOOLEAN;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(Uint8 x) void CIMValue::set(Uint8 x)
 { {
     clear();      _release(_rep);
     _rep->_u._uint8Value = x;      CIMValueType<Uint8>::set(_rep, x);
     _rep->_type = CIMTYPE_UINT8;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(Sint8 x) void CIMValue::set(Sint8 x)
 { {
     clear();      _release(_rep);
     _rep->_u._sint8Value = x;      CIMValueType<Sint8>::set(_rep, x);
     _rep->_type = CIMTYPE_SINT8;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(Uint16 x) void CIMValue::set(Uint16 x)
 { {
     clear();      _release(_rep);
     _rep->_u._uint16Value = x;      CIMValueType<Uint16>::set(_rep, x);
     _rep->_type = CIMTYPE_UINT16;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(Sint16 x) void CIMValue::set(Sint16 x)
 { {
     clear();      _release(_rep);
     _rep->_u._sint16Value = x;      CIMValueType<Sint16>::set(_rep, x);
     _rep->_type = CIMTYPE_SINT16;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(Uint32 x) void CIMValue::set(Uint32 x)
 { {
     clear();      _release(_rep);
     _rep->_u._uint32Value = x;      CIMValueType<Uint32>::set(_rep, x);
     _rep->_type = CIMTYPE_UINT32;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(Sint32 x) void CIMValue::set(Sint32 x)
 { {
     clear();      _release(_rep);
     _rep->_u._sint32Value = x;      CIMValueType<Sint32>::set(_rep, x);
     _rep->_type = CIMTYPE_SINT32;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(Uint64 x) void CIMValue::set(Uint64 x)
 { {
     clear();      _release(_rep);
     _rep->_u._uint64Value = x;      CIMValueType<Uint64>::set(_rep, x);
     _rep->_type = CIMTYPE_UINT64;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(Sint64 x) void CIMValue::set(Sint64 x)
 { {
     clear();      _release(_rep);
     _rep->_u._sint64Value = x;      CIMValueType<Sint64>::set(_rep, x);
     _rep->_type = CIMTYPE_SINT64;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(Real32 x) void CIMValue::set(Real32 x)
 { {
     clear();      _release(_rep);
     _rep->_u._real32Value = x;      CIMValueType<Real32>::set(_rep, x);
     _rep->_type = CIMTYPE_REAL32;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(Real64 x) void CIMValue::set(Real64 x)
 { {
     clear();      _release(_rep);
     _rep->_u._real64Value = x;      CIMValueType<Real64>::set(_rep, x);
     _rep->_type = CIMTYPE_REAL64;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const Char16& x) void CIMValue::set(const Char16& x)
 { {
     clear();      _release(_rep);
     _rep->_u._char16Value = x;      CIMValueType<Char16>::set(_rep, x);
     _rep->_type = CIMTYPE_CHAR16;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const String& x) void CIMValue::set(const String& x)
 { {
     clear();      _release(_rep);
     _rep->_u._stringValue = new String(x);      CIMValueType<String>::set(_rep, x);
     _rep->_type = CIMTYPE_STRING;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const CIMDateTime& x) void CIMValue::set(const CIMDateTime& x)
 { {
     clear();      _release(_rep);
     _rep->_u._dateTimeValue = new CIMDateTime(x);      CIMValueType<CIMDateTime>::set(_rep, x);
     _rep->_type = CIMTYPE_DATETIME;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const CIMObjectPath& x) void CIMValue::set(const CIMObjectPath& x)
 { {
     clear();      _release(_rep);
     _rep->_u._referenceValue = new CIMObjectPath(x);      CIMValueType<CIMObjectPath>::set(_rep, x);
     _rep->_type = CIMTYPE_REFERENCE;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const CIMObject& x) void CIMValue::set(const CIMObject& x)
 { {
     clear();      if (x.isUninitialized())
     if (x.isUninitialized()) {      {
         // Don't need to clone since null CIMObjects aren't shared when created.          // Bug 3373, throw exception on uninitialized object.
         // Doesn't work anyway, clone() throws an exception if null.          throw UninitializedObjectException();
         _rep->_u._cimobjectValue = new CIMObject(x);  
     }     }
     else {  
         _rep->_u._cimobjectValue = new CIMObject(x.clone());      _release(_rep);
       CIMValueType<CIMObject>::set(_rep, x.clone());
     }     }
     _rep->_type = CIMTYPE_OBJECT;  void CIMValue::set(const CIMInstance& x)
     _rep->_isNull = false;  {
       if (x.isUninitialized())
       {
           // Bug 3373, throw exception on uninitialized object.
           throw UninitializedObjectException();
 } }
  
       _release(_rep);
       CIMValueType<CIMInstance>::set(_rep, x.clone());
   }
 void CIMValue::set(const Array<Boolean>& x) void CIMValue::set(const Array<Boolean>& x)
 { {
     clear();      _release(_rep);
     _rep->_u._booleanArray = new Array<Boolean>(x);      CIMValueType<Boolean>::setArray(_rep, x);
     _rep->_type = CIMTYPE_BOOLEAN;  
     _rep->_isArray = true;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const Array<Uint8>& x) void CIMValue::set(const Array<Uint8>& x)
 { {
     clear();      _release(_rep);
     _rep->_u._uint8Array = new Array<Uint8>(x);      CIMValueType<Uint8>::setArray(_rep, x);
     _rep->_type = CIMTYPE_UINT8;  
     _rep->_isArray = true;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const Array<Sint8>& x) void CIMValue::set(const Array<Sint8>& x)
 { {
     clear();      _release(_rep);
     _rep->_u._sint8Array = new Array<Sint8>(x);      CIMValueType<Sint8>::setArray(_rep, x);
     _rep->_type = CIMTYPE_SINT8;  
     _rep->_isArray = true;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const Array<Uint16>& x) void CIMValue::set(const Array<Uint16>& x)
 { {
     clear();      _release(_rep);
     _rep->_u._uint16Array = new Array<Uint16>(x);      CIMValueType<Uint16>::setArray(_rep, x);
     _rep->_type = CIMTYPE_UINT16;  
     _rep->_isArray = true;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const Array<Sint16>& x) void CIMValue::set(const Array<Sint16>& x)
 { {
     clear();      _release(_rep);
     _rep->_u._sint16Array = new Array<Sint16>(x);      CIMValueType<Sint16>::setArray(_rep, x);
     _rep->_type = CIMTYPE_SINT16;  
     _rep->_isArray = true;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const Array<Uint32>& x) void CIMValue::set(const Array<Uint32>& x)
 { {
     clear();      _release(_rep);
     _rep->_u._uint32Array = new Array<Uint32>(x);      CIMValueType<Uint32>::setArray(_rep, x);
     _rep->_type = CIMTYPE_UINT32;  
     _rep->_isArray = true;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const Array<Sint32>& x) void CIMValue::set(const Array<Sint32>& x)
 { {
     clear();      _release(_rep);
     _rep->_u._sint32Array = new Array<Sint32>(x);      CIMValueType<Sint32>::setArray(_rep, x);
     _rep->_type = CIMTYPE_SINT32;  
     _rep->_isArray = true;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const Array<Uint64>& x) void CIMValue::set(const Array<Uint64>& x)
 { {
     clear();      _release(_rep);
     _rep->_u._uint64Array = new Array<Uint64>(x);      CIMValueType<Uint64>::setArray(_rep, x);
     _rep->_type = CIMTYPE_UINT64;  
     _rep->_isArray = true;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const Array<Sint64>& x) void CIMValue::set(const Array<Sint64>& x)
 { {
     clear();      _release(_rep);
     _rep->_u._sint64Array = new Array<Sint64>(x);      CIMValueType<Sint64>::setArray(_rep, x);
     _rep->_type = CIMTYPE_SINT64;  
     _rep->_isArray = true;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const Array<Real32>& x) void CIMValue::set(const Array<Real32>& x)
 { {
     clear();      _release(_rep);
     _rep->_u._real32Array = new Array<Real32>(x);      CIMValueType<Real32>::setArray(_rep, x);
     _rep->_type = CIMTYPE_REAL32;  
     _rep->_isArray = true;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const Array<Real64>& x) void CIMValue::set(const Array<Real64>& x)
 { {
     clear();      _release(_rep);
     _rep->_u._real64Array = new Array<Real64>(x);      CIMValueType<Real64>::setArray(_rep, x);
     _rep->_type = CIMTYPE_REAL64;  
     _rep->_isArray = true;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const Array<Char16>& x) void CIMValue::set(const Array<Char16>& x)
 { {
     clear();      _release(_rep);
     _rep->_u._char16Array = new Array<Char16>(x);      CIMValueType<Char16>::setArray(_rep, x);
     _rep->_type = CIMTYPE_CHAR16;  
     _rep->_isArray = true;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const Array<String>& x) void CIMValue::set(const Array<String>& x)
 { {
     clear();      _release(_rep);
     _rep->_u._stringArray = new Array<String>(x);      CIMValueType<String>::setArray(_rep, x);
     _rep->_type = CIMTYPE_STRING;  
     _rep->_isArray = true;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const Array<CIMDateTime>& x) void CIMValue::set(const Array<CIMDateTime>& x)
 { {
     clear();      _release(_rep);
     _rep->_u._dateTimeArray = new Array<CIMDateTime>(x);      CIMValueType<CIMDateTime>::setArray(_rep, x);
     _rep->_type = CIMTYPE_DATETIME;  
     _rep->_isArray = true;  
     _rep->_isNull = false;  
 } }
  
 void CIMValue::set(const Array<CIMObjectPath>& x) void CIMValue::set(const Array<CIMObjectPath>& x)
 { {
     clear();      _release(_rep);
     _rep->_u._referenceArray = new Array<CIMObjectPath>(x);      CIMValueType<CIMObjectPath>::setArray(_rep, x);
     _rep->_type = CIMTYPE_REFERENCE;  }
     _rep->_isArray = true;  
     _rep->_isNull = false;  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);
   }
   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<CIMObject>& x)          tmp.append(a[i].clone());
 {  
     clear();  
     _rep->_u._cimobjectArray = new Array<CIMObject>(x);  
     _rep->_type = CIMTYPE_OBJECT;  
     _rep->_isArray = true;  
     _rep->_isNull = false;  
 } }
  
       _release(_rep);
       CIMValueType<CIMInstance>::setArray(_rep, tmp);
   }
 void CIMValue::get(Boolean& x) const void CIMValue::get(Boolean& x) const
 { {
     if (_rep->_type != CIMTYPE_BOOLEAN || _rep->_isArray)      if (_rep->type != CIMTYPE_BOOLEAN || _rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = _rep->_u._booleanValue != 0;          x = CIMValueType<Boolean>::ref(_rep);
 } }
  
 void CIMValue::get(Uint8& x) const void CIMValue::get(Uint8& x) const
 { {
     if (_rep->_type != CIMTYPE_UINT8 || _rep->_isArray)      if (_rep->type != CIMTYPE_UINT8 || _rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = _rep->_u._uint8Value;          x = CIMValueType<Uint8>::ref(_rep);
 } }
  
 void CIMValue::get(Sint8& x) const void CIMValue::get(Sint8& x) const
 { {
     if (_rep->_type != CIMTYPE_SINT8 || _rep->_isArray)      if (_rep->type != CIMTYPE_SINT8 || _rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = _rep->_u._sint8Value;          x = CIMValueType<Sint8>::ref(_rep);
 } }
  
 void CIMValue::get(Uint16& x) const void CIMValue::get(Uint16& x) const
 { {
     if (_rep->_type != CIMTYPE_UINT16 || _rep->_isArray)      if (_rep->type != CIMTYPE_UINT16 || _rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = _rep->_u._uint16Value;          x = CIMValueType<Uint16>::ref(_rep);
 } }
  
 void CIMValue::get(Sint16& x) const void CIMValue::get(Sint16& x) const
 { {
     if (_rep->_type != CIMTYPE_SINT16 || _rep->_isArray)      if (_rep->type != CIMTYPE_SINT16 || _rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = _rep->_u._sint16Value;          x = CIMValueType<Sint16>::ref(_rep);
 } }
  
   
 void CIMValue::get(Uint32& x) const void CIMValue::get(Uint32& x) const
 { {
     if (_rep->_type != CIMTYPE_UINT32 || _rep->_isArray)      if (_rep->type != CIMTYPE_UINT32 || _rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = _rep->_u._uint32Value;          x = CIMValueType<Uint32>::ref(_rep);
 } }
  
 void CIMValue::get(Sint32& x) const void CIMValue::get(Sint32& x) const
 { {
     if (_rep->_type != CIMTYPE_SINT32 || _rep->_isArray)      if (_rep->type != CIMTYPE_SINT32 || _rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = _rep->_u._sint32Value;          x = CIMValueType<Sint32>::ref(_rep);
 } }
  
 void CIMValue::get(Uint64& x) const void CIMValue::get(Uint64& x) const
 { {
     if (_rep->_type != CIMTYPE_UINT64 || _rep->_isArray)      if (_rep->type != CIMTYPE_UINT64 || _rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = _rep->_u._uint64Value;          x = CIMValueType<Uint64>::ref(_rep);
 } }
  
 void CIMValue::get(Sint64& x) const void CIMValue::get(Sint64& x) const
 { {
     if (_rep->_type != CIMTYPE_SINT64 || _rep->_isArray)      if (_rep->type != CIMTYPE_SINT64 || _rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = _rep->_u._sint64Value;          x = CIMValueType<Sint64>::ref(_rep);
 } }
  
 void CIMValue::get(Real32& x) const void CIMValue::get(Real32& x) const
 { {
     if (_rep->_type != CIMTYPE_REAL32 || _rep->_isArray)      if (_rep->type != CIMTYPE_REAL32 || _rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = _rep->_u._real32Value;          x = CIMValueType<Real32>::ref(_rep);
 } }
  
 void CIMValue::get(Real64& x) const void CIMValue::get(Real64& x) const
 { {
     if (_rep->_type != CIMTYPE_REAL64 || _rep->_isArray)      if (_rep->type != CIMTYPE_REAL64 || _rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = _rep->_u._real64Value;          x = CIMValueType<Real64>::ref(_rep);
 } }
  
 void CIMValue::get(Char16& x) const void CIMValue::get(Char16& x) const
 { {
     if (_rep->_type != CIMTYPE_CHAR16 || _rep->_isArray)      if (_rep->type != CIMTYPE_CHAR16 || _rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = _rep->_u._char16Value;          x = CIMValueType<Char16>::ref(_rep);
 } }
  
 void CIMValue::get(String& x) const void CIMValue::get(String& x) const
 { {
     if (_rep->_type != CIMTYPE_STRING || _rep->_isArray)      if (_rep->type != CIMTYPE_STRING || _rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._stringValue;          x = CIMValueType<String>::ref(_rep);
 } }
  
 void CIMValue::get(CIMDateTime& x) const void CIMValue::get(CIMDateTime& x) const
 { {
     if (_rep->_type != CIMTYPE_DATETIME || _rep->_isArray)      if (_rep->type != CIMTYPE_DATETIME || _rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._dateTimeValue;          x = CIMValueType<CIMDateTime>::ref(_rep);
 } }
  
 void CIMValue::get(CIMObjectPath& x) const void CIMValue::get(CIMObjectPath& x) const
 { {
     if (_rep->_type != CIMTYPE_REFERENCE || _rep->_isArray)      if (_rep->type != CIMTYPE_REFERENCE || _rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._referenceValue;          x = CIMValueType<CIMObjectPath>::ref(_rep);
 } }
  
 void CIMValue::get(CIMObject& x) const void CIMValue::get(CIMObject& x) const
 { {
     if (_rep->_type != CIMTYPE_OBJECT || _rep->_isArray)      if (_rep->type != CIMTYPE_OBJECT || _rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._cimobjectValue;          // 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();
 } }
   void CIMValue::get(CIMInstance& x) const
   {
       if (_rep->type != CIMTYPE_INSTANCE || _rep->isArray)
           throw TypeMismatchException();
  
       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<CIMInstance>::ref(_rep).clone();
       }
   }
 void CIMValue::get(Array<Boolean>& x) const void CIMValue::get(Array<Boolean>& x) const
 { {
     if (_rep->_type != CIMTYPE_BOOLEAN || !_rep->_isArray)      if (_rep->type != CIMTYPE_BOOLEAN || !_rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._booleanArray;          x = CIMValueType<Boolean>::aref(_rep);
 } }
  
 void CIMValue::get(Array<Uint8>& x) const void CIMValue::get(Array<Uint8>& x) const
 { {
     if (_rep->_type != CIMTYPE_UINT8 || !_rep->_isArray)      if (_rep->type != CIMTYPE_UINT8 || !_rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._uint8Array;          x = CIMValueType<Uint8>::aref(_rep);
 } }
  
 void CIMValue::get(Array<Sint8>& x) const void CIMValue::get(Array<Sint8>& x) const
 { {
     if (_rep->_type != CIMTYPE_SINT8 || !_rep->_isArray)      if (_rep->type != CIMTYPE_SINT8 || !_rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._sint8Array;          x = CIMValueType<Sint8>::aref(_rep);
 } }
  
 void CIMValue::get(Array<Uint16>& x) const void CIMValue::get(Array<Uint16>& x) const
 { {
     if (_rep->_type != CIMTYPE_UINT16 || !_rep->_isArray)      if (_rep->type != CIMTYPE_UINT16 || !_rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._uint16Array;          x = CIMValueType<Uint16>::aref(_rep);
 } }
  
 void CIMValue::get(Array<Sint16>& x) const void CIMValue::get(Array<Sint16>& x) const
 { {
     if (_rep->_type != CIMTYPE_SINT16 || !_rep->_isArray)      if (_rep->type != CIMTYPE_SINT16 || !_rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._sint16Array;          x = CIMValueType<Sint16>::aref(_rep);
 } }
  
 void CIMValue::get(Array<Uint32>& x) const void CIMValue::get(Array<Uint32>& x) const
 { {
     if (_rep->_type != CIMTYPE_UINT32 || !_rep->_isArray)      if (_rep->type != CIMTYPE_UINT32 || !_rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._uint32Array;          x = CIMValueType<Uint32>::aref(_rep);
 } }
  
 void CIMValue::get(Array<Sint32>& x) const void CIMValue::get(Array<Sint32>& x) const
 { {
     if (_rep->_type != CIMTYPE_SINT32 || !_rep->_isArray)      if (_rep->type != CIMTYPE_SINT32 || !_rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._sint32Array;          x = CIMValueType<Sint32>::aref(_rep);
 } }
  
 void CIMValue::get(Array<Uint64>& x) const void CIMValue::get(Array<Uint64>& x) const
 { {
     if (_rep->_type != CIMTYPE_UINT64 || !_rep->_isArray)      if (_rep->type != CIMTYPE_UINT64 || !_rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._uint64Array;          x = CIMValueType<Uint64>::aref(_rep);
 } }
  
 void CIMValue::get(Array<Sint64>& x) const void CIMValue::get(Array<Sint64>& x) const
 { {
     if (_rep->_type != CIMTYPE_SINT64 || !_rep->_isArray)      if (_rep->type != CIMTYPE_SINT64 || !_rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._sint64Array;          x = CIMValueType<Sint64>::aref(_rep);
 } }
  
 void CIMValue::get(Array<Real32>& x) const void CIMValue::get(Array<Real32>& x) const
 { {
     if (_rep->_type != CIMTYPE_REAL32 || !_rep->_isArray)      if (_rep->type != CIMTYPE_REAL32 || !_rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._real32Array;          x = CIMValueType<Real32>::aref(_rep);
 } }
  
 void CIMValue::get(Array<Real64>& x) const void CIMValue::get(Array<Real64>& x) const
 { {
     if (_rep->_type != CIMTYPE_REAL64 || !_rep->_isArray)      if (_rep->type != CIMTYPE_REAL64 || !_rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._real64Array;          x = CIMValueType<Real64>::aref(_rep);
 } }
  
 void CIMValue::get(Array<Char16>& x) const void CIMValue::get(Array<Char16>& x) const
 { {
     if (_rep->_type != CIMTYPE_CHAR16 || !_rep->_isArray)      if (_rep->type != CIMTYPE_CHAR16 || !_rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._char16Array;          x = CIMValueType<Char16>::aref(_rep);
 } }
  
 void CIMValue::get(Array<String>& x) const void CIMValue::get(Array<String>& x) const
 { {
     if (_rep->_type != CIMTYPE_STRING || !_rep->_isArray)      if (_rep->type != CIMTYPE_STRING || !_rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._stringArray;          x = CIMValueType<String>::aref(_rep);
 } }
  
 void CIMValue::get(Array<CIMDateTime>& x) const void CIMValue::get(Array<CIMDateTime>& x) const
 { {
     if (_rep->_type != CIMTYPE_DATETIME || !_rep->_isArray)      if (_rep->type != CIMTYPE_DATETIME || !_rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._dateTimeArray;          x = CIMValueType<CIMDateTime>::aref(_rep);
 } }
  
 void CIMValue::get(Array<CIMObjectPath>& x) const void CIMValue::get(Array<CIMObjectPath>& x) const
 { {
     if (_rep->_type != CIMTYPE_REFERENCE || !_rep->_isArray)      if (_rep->type != CIMTYPE_REFERENCE || !_rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._referenceArray;          x = CIMValueType<CIMObjectPath>::aref(_rep);
 } }
  
 void CIMValue::get(Array<CIMObject>& x) const void CIMValue::get(Array<CIMObject>& x) const
 { {
     if (_rep->_type != CIMTYPE_OBJECT || !_rep->_isArray)      if (_rep->type != CIMTYPE_OBJECT || !_rep->isArray)
           throw TypeMismatchException();
   
       if (!_rep->isNull)
       {
           x.clear();
   
           // 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());
           }
       }
   }
   
   void CIMValue::get(Array<CIMInstance>& x) const
   {
       if (_rep->type != CIMTYPE_INSTANCE || !_rep->isArray)
         throw TypeMismatchException();         throw TypeMismatchException();
  
     if (!_rep->_isNull)      if (!_rep->isNull)
         x = *_rep->_u._cimobjectArray;      {
           x.clear();
   
           // 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<CIMInstance>::arraySize(_rep);
                i < n; i++)
           {
               x.append(CIMValueType<CIMInstance>::aref(_rep)[i].clone());
           }
       }
 } }
  
 Boolean CIMValue::equal(const CIMValue& x) const Boolean CIMValue::equal(const CIMValue& x) const
Line 1478 
Line 1391 
     if (!typeCompatible(x))     if (!typeCompatible(x))
         return false;         return false;
  
     if (_rep->_isNull != x._rep->_isNull)      if (_rep->isNull != x._rep->isNull)
         return false;         return false;
  
     if (_rep->_isArray)      if (_rep->isNull)
           return true;
   
       if (_rep->isArray)
     {     {
         switch (_rep->_type)          switch (_rep->type)
         {         {
             case CIMTYPE_BOOLEAN:             case CIMTYPE_BOOLEAN:
                 return (*_rep->_u._booleanArray) ==                  return CIMValueType<Boolean>::equalArray(_rep, x._rep);
                     (*x._rep->_u._booleanArray);  
  
             case CIMTYPE_UINT8:             case CIMTYPE_UINT8:
                 return (*_rep->_u._uint8Array) ==                  return CIMValueType<Uint8>::equalArray(_rep, x._rep);
                     (*x._rep->_u._uint8Array);  
  
             case CIMTYPE_SINT8:             case CIMTYPE_SINT8:
                 return (*_rep->_u._sint8Array) ==                  return CIMValueType<Sint8>::equalArray(_rep, x._rep);
                     (*x._rep->_u._sint8Array);  
  
             case CIMTYPE_UINT16:             case CIMTYPE_UINT16:
                 return (*_rep->_u._uint16Array) ==                  return CIMValueType<Uint16>::equalArray(_rep, x._rep);
                     (*x._rep->_u._uint16Array);  
  
             case CIMTYPE_SINT16:             case CIMTYPE_SINT16:
                 return (*_rep->_u._sint16Array) ==                  return CIMValueType<Sint16>::equalArray(_rep, x._rep);
                     (*x._rep->_u._sint16Array);  
  
             case CIMTYPE_UINT32:             case CIMTYPE_UINT32:
                 return (*_rep->_u._uint32Array) ==                  return CIMValueType<Uint32>::equalArray(_rep, x._rep);
                     (*x._rep->_u._uint32Array);  
  
             case CIMTYPE_SINT32:             case CIMTYPE_SINT32:
                 return (*_rep->_u._sint32Array) ==                  return CIMValueType<Sint32>::equalArray(_rep, x._rep);
                     (*x._rep->_u._sint32Array);  
  
             case CIMTYPE_UINT64:             case CIMTYPE_UINT64:
                 return (*_rep->_u._uint64Array) ==                  return CIMValueType<Uint64>::equalArray(_rep, x._rep);
                     (*x._rep->_u._uint64Array);  
  
             case CIMTYPE_SINT64:             case CIMTYPE_SINT64:
                 return (*_rep->_u._sint64Array) ==                  return CIMValueType<Sint64>::equalArray(_rep, x._rep);
                     (*x._rep->_u._sint64Array);  
  
             case CIMTYPE_REAL32:             case CIMTYPE_REAL32:
                 return (*_rep->_u._real32Array) ==                  return CIMValueType<Real32>::equalArray(_rep, x._rep);
                     (*x._rep->_u._real32Array);  
  
             case CIMTYPE_REAL64:             case CIMTYPE_REAL64:
                 return (*_rep->_u._real64Array) ==                  return CIMValueType<Real64>::equalArray(_rep, x._rep);
                     (*x._rep->_u._real64Array);  
  
             case CIMTYPE_CHAR16:             case CIMTYPE_CHAR16:
                 return (*_rep->_u._char16Array) ==                  return CIMValueType<Char16>::equalArray(_rep, x._rep);
                     (*x._rep->_u._char16Array);  
  
             case CIMTYPE_STRING:             case CIMTYPE_STRING:
                 return (*_rep->_u._stringArray) ==                  return CIMValueType<String>::equalArray(_rep, x._rep);
                     (*x._rep->_u._stringArray);  
  
             case CIMTYPE_DATETIME:             case CIMTYPE_DATETIME:
                 return (*_rep->_u._dateTimeArray) ==                  return CIMValueType<CIMDateTime>::equalArray(_rep, x._rep);
                     (*x._rep->_u._dateTimeArray);  
  
             case CIMTYPE_REFERENCE:             case CIMTYPE_REFERENCE:
                 return (*_rep->_u._referenceArray) ==                  return CIMValueType<CIMObjectPath>::equalArray(_rep, x._rep);
                     (*x._rep->_u._referenceArray);  
  
             case CIMTYPE_OBJECT:             case CIMTYPE_OBJECT:
                 return (*_rep->_u._cimobjectArray) ==                  return CIMValueType<CIMObject>::equalArray(_rep, x._rep);
                     (*x._rep->_u._cimobjectArray);              case CIMTYPE_INSTANCE:
                   return CIMValueType<CIMInstance>::equalArray(_rep, x._rep);
             default:             default:
                 PEGASUS_ASSERT(false);                  PEGASUS_ASSERT(0);
         }         }
     }     }
     else     else
     {     {
         switch (_rep->_type)          switch (_rep->type)
         {         {
             case CIMTYPE_BOOLEAN:             case CIMTYPE_BOOLEAN:
                 return _rep->_u._booleanValue == x._rep->_u._booleanValue;                  return CIMValueType<Boolean>::equal(_rep, x._rep);
  
             case CIMTYPE_UINT8:             case CIMTYPE_UINT8:
                 return _rep->_u._uint8Value == x._rep->_u._uint8Value;                  return CIMValueType<Uint8>::equal(_rep, x._rep);
  
             case CIMTYPE_SINT8:             case CIMTYPE_SINT8:
                 return _rep->_u._sint8Value == x._rep->_u._sint8Value;                  return CIMValueType<Sint8>::equal(_rep, x._rep);
  
             case CIMTYPE_UINT16:             case CIMTYPE_UINT16:
                 return _rep->_u._uint16Value == x._rep->_u._uint16Value;                  return CIMValueType<Uint16>::equal(_rep, x._rep);
  
             case CIMTYPE_SINT16:             case CIMTYPE_SINT16:
                 return _rep->_u._sint16Value == x._rep->_u._sint16Value;                  return CIMValueType<Sint16>::equal(_rep, x._rep);
  
             case CIMTYPE_UINT32:             case CIMTYPE_UINT32:
                 return _rep->_u._uint32Value == x._rep->_u._uint32Value;                  return CIMValueType<Uint32>::equal(_rep, x._rep);
  
             case CIMTYPE_SINT32:             case CIMTYPE_SINT32:
                 return _rep->_u._sint32Value == x._rep->_u._sint32Value;                  return CIMValueType<Sint32>::equal(_rep, x._rep);
  
             case CIMTYPE_UINT64:             case CIMTYPE_UINT64:
                 return _rep->_u._uint64Value == x._rep->_u._uint64Value;                  return CIMValueType<Uint64>::equal(_rep, x._rep);
  
             case CIMTYPE_SINT64:             case CIMTYPE_SINT64:
                 return _rep->_u._sint64Value == x._rep->_u._sint64Value;                  return CIMValueType<Sint64>::equal(_rep, x._rep);
  
             case CIMTYPE_REAL32:             case CIMTYPE_REAL32:
                 return _rep->_u._real32Value == x._rep->_u._real32Value;                  return CIMValueType<Real32>::equal(_rep, x._rep);
  
             case CIMTYPE_REAL64:             case CIMTYPE_REAL64:
                 return _rep->_u._real64Value == x._rep->_u._real64Value;                  return CIMValueType<Real64>::equal(_rep, x._rep);
  
             case CIMTYPE_CHAR16:             case CIMTYPE_CHAR16:
                 return _rep->_u._char16Value == x._rep->_u._char16Value;                  return CIMValueType<Char16>::equal(_rep, x._rep);
  
             case CIMTYPE_STRING:             case CIMTYPE_STRING:
                 return String::equal(*_rep->_u._stringValue,                  return CIMValueType<String>::equal(_rep, x._rep);
                                      *x._rep->_u._stringValue);  
  
             case CIMTYPE_DATETIME:             case CIMTYPE_DATETIME:
                 return *_rep->_u._dateTimeValue == *x._rep->_u._dateTimeValue;                  return CIMValueType<CIMDateTime>::equal(_rep, x._rep);
  
             case CIMTYPE_REFERENCE:             case CIMTYPE_REFERENCE:
                 return *_rep->_u._referenceValue ==                  return CIMValueType<CIMObjectPath>::equal(_rep, x._rep);
                     *x._rep->_u._referenceValue;  
  
             case CIMTYPE_OBJECT:             case CIMTYPE_OBJECT:
                 return (*_rep->_u._cimobjectValue).identical((*x._rep->_u._cimobjectValue));                  return CIMValueType<CIMObject>::ref(_rep).identical(
                       CIMValueType<CIMObject>::ref(x._rep));
               case CIMTYPE_INSTANCE:
                   return CIMValueType<CIMInstance>::ref(_rep).identical(
                       CIMValueType<CIMInstance>::ref(x._rep));
             default:             default:
                 PEGASUS_ASSERT(false);                  PEGASUS_ASSERT(0);
         }         }
     }     }
  
     // Unreachable!  
     return false;     return false;
 } }
  
 String CIMValue::toString() const String CIMValue::toString() const
 { {
     Array<Sint8> out;      Buffer out;
  
     //ATTN: Not sure what we should do with getstring for Null CIMValues     //ATTN: Not sure what we should do with getstring for Null CIMValues
     //Choice return empty string or exception out.     //Choice return empty string or exception out.
     if (_rep->_isNull)  
       if (_rep->isNull)
         return String();         return String();
  
     if (_rep->_isArray)      if (_rep->isArray)
     {     {
         switch (_rep->_type)          switch (_rep->type)
         {         {
             case CIMTYPE_BOOLEAN:             case CIMTYPE_BOOLEAN:
             {             {
                 Uint32 size = _rep->_u._booleanArray->size();                  const Array<Boolean>& a = CIMValueType<Boolean>::aref(_rep);
                   Uint32 size = a.size();
   
                 for (Uint32 i = 0; i < size; i++)                 for (Uint32 i = 0; i < size; i++)
                 {                 {
                     _toString(out, Boolean(_rep->_u._booleanArray->getData()[i]));                      _toString(out, a[i]);
                     out << " ";                      out.append(' ');
                 }                 }
                 break;                 break;
             }             }
  
             case CIMTYPE_UINT8:             case CIMTYPE_UINT8:
                 _toString(out, _rep->_u._uint8Array->getData(),              {
                                _rep->_u._uint8Array->size());                  const Array<Uint8>& a = CIMValueType<Uint8>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMTYPE_SINT8:             case CIMTYPE_SINT8:
                 _toString(out, _rep->_u._sint8Array->getData(),              {
                                _rep->_u._sint8Array->size());                  const Array<Sint8>& a = CIMValueType<Sint8>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMTYPE_UINT16:             case CIMTYPE_UINT16:
                 _toString(out, _rep->_u._uint16Array->getData(),              {
                                _rep->_u._uint16Array->size());                  const Array<Uint16>& a = CIMValueType<Uint16>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMTYPE_SINT16:             case CIMTYPE_SINT16:
                 _toString(out, _rep->_u._sint16Array->getData(),              {
                                _rep->_u._sint16Array->size());                  const Array<Sint16>& a = CIMValueType<Sint16>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMTYPE_UINT32:             case CIMTYPE_UINT32:
                 _toString(out, _rep->_u._uint32Array->getData(),              {
                                _rep->_u._uint32Array->size());                  const Array<Uint32>& a = CIMValueType<Uint32>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMTYPE_SINT32:             case CIMTYPE_SINT32:
                 _toString(out, _rep->_u._sint32Array->getData(),              {
                                _rep->_u._sint32Array->size());                  const Array<Sint32>& a = CIMValueType<Sint32>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMTYPE_UINT64:             case CIMTYPE_UINT64:
                 _toString(out, _rep->_u._uint64Array->getData(),              {
                                _rep->_u._uint64Array->size());                  const Array<Uint64>& a = CIMValueType<Uint64>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMTYPE_SINT64:             case CIMTYPE_SINT64:
                 _toString(out, _rep->_u._sint64Array->getData(),              {
                                _rep->_u._sint64Array->size());                  const Array<Sint64>& a = CIMValueType<Sint64>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMTYPE_REAL32:             case CIMTYPE_REAL32:
                 _toString(out, _rep->_u._real32Array->getData(),              {
                                _rep->_u._real32Array->size());                  const Array<Real32>& a = CIMValueType<Real32>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMTYPE_REAL64:             case CIMTYPE_REAL64:
                 _toString(out, _rep->_u._real64Array->getData(),              {
                                _rep->_u._real64Array->size());                  const Array<Real64>& a = CIMValueType<Real64>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMTYPE_CHAR16:             case CIMTYPE_CHAR16:
                 _toString(out, _rep->_u._char16Array->getData(),              {
                                _rep->_u._char16Array->size());                  const Array<Char16>& a = CIMValueType<Char16>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMTYPE_STRING:             case CIMTYPE_STRING:
                 _toString(out, _rep->_u._stringArray->getData(),              {
                                _rep->_u._stringArray->size());                  const Array<String>& a = CIMValueType<String>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMTYPE_DATETIME:             case CIMTYPE_DATETIME:
                 _toString(out, _rep->_u._dateTimeArray->getData(),              {
                                _rep->_u._dateTimeArray->size());                  const Array<CIMDateTime>& a =
                       CIMValueType<CIMDateTime>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMTYPE_REFERENCE:             case CIMTYPE_REFERENCE:
                 _toString(out, _rep->_u._referenceArray->getData(),              {
                                _rep->_u._referenceArray->size());                  const Array<CIMObjectPath>& a =
                       CIMValueType<CIMObjectPath>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
  
             case CIMTYPE_OBJECT:             case CIMTYPE_OBJECT:
                 _toString(out, _rep->_u._cimobjectArray->getData(),              {
                                _rep->_u._cimobjectArray->size());                  const Array<CIMObject>& a = CIMValueType<CIMObject>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                 break;                 break;
               }
               case CIMTYPE_INSTANCE:
               {
                   const Array<CIMInstance>& a =
                       CIMValueType<CIMInstance>::aref(_rep);
                   _toString(out, a.getData(), a.size());
                   break;
               }
             default:             default:
                 PEGASUS_ASSERT(false);                  PEGASUS_ASSERT(0);
         }         }
     }     }
     else     else
     {     {
         switch (_rep->_type)          switch (_rep->type)
         {         {
             case CIMTYPE_BOOLEAN:             case CIMTYPE_BOOLEAN:
                 _toString(out, Boolean(_rep->_u._booleanValue != 0));                  _toString(out, CIMValueType<Boolean>::ref(_rep));
                 break;                 break;
  
             case CIMTYPE_UINT8:             case CIMTYPE_UINT8:
                 _toString(out, _rep->_u._uint8Value);                  _toString(out, CIMValueType<Uint8>::ref(_rep));
                 break;                 break;
  
             case CIMTYPE_SINT8:             case CIMTYPE_SINT8:
                 _toString(out, _rep->_u._sint8Value);                  _toString(out, CIMValueType<Sint8>::ref(_rep));
                 break;                 break;
  
             case CIMTYPE_UINT16:             case CIMTYPE_UINT16:
                 _toString(out, _rep->_u._uint16Value);                  _toString(out, CIMValueType<Uint16>::ref(_rep));
                 break;                 break;
  
             case CIMTYPE_SINT16:             case CIMTYPE_SINT16:
                 _toString(out, _rep->_u._sint16Value);                  _toString(out, CIMValueType<Sint16>::ref(_rep));
                 break;                 break;
  
             case CIMTYPE_UINT32:             case CIMTYPE_UINT32:
                 _toString(out, _rep->_u._uint32Value);                  _toString(out, CIMValueType<Uint32>::ref(_rep));
                 break;                 break;
  
             case CIMTYPE_SINT32:             case CIMTYPE_SINT32:
                 _toString(out, _rep->_u._sint32Value);                  _toString(out, CIMValueType<Sint32>::ref(_rep));
                 break;                 break;
  
             case CIMTYPE_UINT64:             case CIMTYPE_UINT64:
                 _toString(out, _rep->_u._uint64Value);                  _toString(out, CIMValueType<Uint64>::ref(_rep));
                 break;                 break;
  
             case CIMTYPE_SINT64:             case CIMTYPE_SINT64:
                 _toString(out, _rep->_u._sint64Value);                  _toString(out, CIMValueType<Sint64>::ref(_rep));
                 break;                 break;
  
             case CIMTYPE_REAL32:             case CIMTYPE_REAL32:
                 _toString(out, _rep->_u._real32Value);                  _toString(out, CIMValueType<Real32>::ref(_rep));
                 break;                 break;
  
             case CIMTYPE_REAL64:             case CIMTYPE_REAL64:
                 _toString(out, _rep->_u._real64Value);                  _toString(out, CIMValueType<Real64>::ref(_rep));
                 break;                 break;
  
             case CIMTYPE_CHAR16:             case CIMTYPE_CHAR16:
                 _toString(out, Char16(_rep->_u._char16Value));                  _toString(out, CIMValueType<Char16>::ref(_rep));
                 break;                 break;
  
             case CIMTYPE_STRING:             case CIMTYPE_STRING:
                 _toString(out, *_rep->_u._stringValue);                  _toString(out, CIMValueType<String>::ref(_rep));
                 break;                 break;
  
             case CIMTYPE_DATETIME:             case CIMTYPE_DATETIME:
                 _toString(out, *_rep->_u._dateTimeValue);                  _toString(out, CIMValueType<CIMDateTime>::ref(_rep));
                 break;                 break;
  
             case CIMTYPE_REFERENCE:             case CIMTYPE_REFERENCE:
                 _toString(out, *_rep->_u._referenceValue);                  _toString(out, CIMValueType<CIMObjectPath>::ref(_rep));
                 break;                 break;
  
             case CIMTYPE_OBJECT:             case CIMTYPE_OBJECT:
                 _toString(out, *_rep->_u._cimobjectValue);                  _toString(out, CIMValueType<CIMObject>::ref(_rep));
                   break;
               case CIMTYPE_INSTANCE:
                   _toString(out, CIMValueType<CIMInstance>::ref(_rep));
                 break;                 break;
   
             default:             default:
                 PEGASUS_ASSERT(false);                  PEGASUS_ASSERT(0);
         }         }
     }     }
  
     out.append('\0');  
     return out.getData();     return out.getData();
 } }
  
   #ifdef PEGASUS_USE_DEPRECATED_INTERFACES
   
   CIMValue::CIMValue(char x)
   {
       _rep = new CIMValueRep;
       CIMValueType<Sint8>::set(_rep, (Sint8)x);
   }
   
   CIMValue::CIMValue(const Array<char>& x)
   {
       _rep = new CIMValueRep;
       Array<Sint8> tmp((Sint8*)x.getData(), x.size());
       CIMValueType<Sint8>::setArray(_rep, tmp);
   }
   
   void CIMValue::set(char x)
   {
       set(static_cast<Sint8>(x));
   }
   
   void CIMValue::set(const Array<char>& x)
   {
       set(*reinterpret_cast<const Array<Sint8>*>(&x));
   }
   
   void CIMValue::get(char& x) const
   {
       get(*reinterpret_cast<Sint8*>(&x));
   }
   
   void CIMValue::get(Array<char>& x) const
   {
       get(*reinterpret_cast<Array<Sint8>*>(&x));
   }
   
   #endif /* PEGASUS_USE_DEPRECATED_INTERFACES */
   
   void CIMValue::_get(const String*& data, Uint32& size) const
   {
       const Array<String>& a = CIMValueType<String>::aref(_rep);
       data = a.getData();
       size = a.size();
   }
  
 Boolean operator==(const CIMValue& x, const CIMValue& y) Boolean operator==(const CIMValue& x, const CIMValue& y)
 { {

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