pegasus/src/Pegasus/Common/CIMValue.cpp - diff

Return to CIMValue.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/CIMValue.cpp between version 1.24 and 1.59.2.1

version 1.24, 2002/04/01 19:06:03

version 1.59.2.1, 2005/09/30 16:28:15

Line 1

//%/////////////////////////////////////////////////////////////////////////////

//%2005////////////////////////////////////////////////////////////////////////

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// IBM Corp.; EMC Corporation, The Open Group.

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 24

Line 31

// 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

// Dave Sudlik, IBM (dsudlik@us.ibm.com)

// David Dillard, VERITAS Software Corp.

// (david.dillard@veritas.com)

//%/////////////////////////////////////////////////////////////////////////////

#include <cstring>

#include <cstdio>

#include <cassert>

#include <cctype>

#include "CIMValue.h"

#include "Union.h"

#include "Indentor.h"

#include "Exception.h"

#include "XmlWriter.h"

#include "CommonUTF.h"

#include "CIMValueRep.h"

PEGASUS_NAMESPACE_BEGIN

Line 42

Line 57

# include "ArrayImpl.h"

#undef PEGASUS_ARRAY_T

template<class T>

inline void _Inc(ArrayRep<T>* rep)

{

ArrayRep<T>::inc(rep);

}

template<class T>

inline void _Dec(ArrayRep<T>* rep)

{

ArrayRep<T>::dec(rep);

}

////////////////////////////////////////////////////////////////////////////////

// Local helper functions:

////////////////////////////////////////////////////////////////////////////////

// Too complicated. Commented out in favor of sprintf("%lld"/"%llu").

#if 0

//------------------------------------------------------------------------------

// _SignedIntToStr()

// _toString routines:

//------------------------------------------------------------------------------

////////////////////////////////////////////////////////////////////////////////

static void _SignedIntToStr(Sint64 x, char* result)

{

if (!result)

return;

if (x == 0)

inline void _toString(Buffer& out, Boolean x)

{

result[0] = '0';

XmlWriter::append(out, x);

result[1] = '\0';

return;

}

char buffer[32];

inline void _toString(Buffer& out, Uint8 x) { XmlWriter::append(out, Uint32(x)); }

Uint32 len = 0;

inline void _toString(Buffer& out, Sint8 x) { XmlWriter::append(out, Sint32(x)); }

Boolean negative = false;

inline void _toString(Buffer& out, Uint16 x) { XmlWriter::append(out, Uint32(x)); }

inline void _toString(Buffer& out, Sint16 x) { XmlWriter::append(out, Sint32(x)); }

while (x)

inline void _toString(Buffer& out, Uint32 x) { XmlWriter::append(out, x); }

{

inline void _toString(Buffer& out, Sint32 x) { XmlWriter::append(out, x); }

Sint32 r = x % 10;

inline void _toString(Buffer& out, Uint64 x) { XmlWriter::append(out, x); }

x = x / 10;

inline void _toString(Buffer& out, Sint64 x) { XmlWriter::append(out, x); }

inline void _toString(Buffer& out, Real32 x) { XmlWriter::append(out, Real64(x)); }

inline void _toString(Buffer& out, Real64 x) { XmlWriter::append(out, x); }

if (r < 0)

inline void _toString(Buffer& out, Char16 x)

{

r = -r;

// We need to convert the Char16 to UTF8 then append the UTF8

negative = true;

// character into the array.

}

// NOTE: The UTF8 character could be several bytes long.

// WARNING: This function will put in replacement character for

buffer[len++] = r + '0';

// all characters that have surogate pairs.

}

buffer[len] = '\0';

char str[6];

memset(str,0x00,sizeof(str));

char* charIN = (char *)&x;

// If buffer was negative, prepend sign:

const Uint16 *strsrc = (Uint16 *)charIN;

Uint16 *endsrc = (Uint16 *)&charIN[1];

char* q = result;

Uint8 *strtgt = (Uint8 *)str;

Uint8 *endtgt = (Uint8 *)&str[5];

if (negative)

UTF16toUTF8(&strsrc,

*q++ = '-';

endsrc,

&strtgt,

endtgt);

// Reverse the buffer:

out.append(str, UTF_8_COUNT_TRAIL_BYTES(str[0]) +1);

char* p = &buffer[len];

while (len--)

*q++ = *--p;

*q++ = '\0';

}

//------------------------------------------------------------------------------

inline void _toString(Buffer& out, const String& x)

// _UnsignedIntToStr()

//------------------------------------------------------------------------------

static void _UnsignedIntToStr(Uint64 x, char* result)

{

if (!result)

out << x;

return;

}

if (x == 0)

inline void _toString(Buffer& out, const CIMDateTime& x)

{

result[0] = '0';

out << x.toString();

result[1] = '\0';

return;

}

char buffer[32];

inline void _toString(Buffer& out, const CIMObjectPath& x)

Uint32 len = 0;

while (x)

{

Uint32 r = x % 10;

out << x.toString();

x = x / 10;

buffer[len++] = r + '0';

}

buffer[len] = '\0';

inline void _toString(Buffer& out, const CIMObject& x)

{

// Reverse the buffer onto output:

out << x.toString();

}

char* q = result;

char* p = &buffer[len];

while (len--)

*q++ = *--p;

*q++ = '\0';

template<class T>

void _toString(Buffer& out, const T* p, Uint32 size)

{

while (size--)

{

_toString(out, *p++);

out << " ";

}

#endif

}

//------------------------------------------------------------------------------

////////////////////////////////////////////////////////////////////////////////

// _toString, _toXml(), and _toMof routines:

// CIMValue

//------------------------------------------------------------------------------

////////////////////////////////////////////////////////////////////////////////

inline void _toString(Array<Sint8>& out, Boolean x)

CIMValue::CIMValue()

{

out << (x ? "TRUE" : "FALSE");

_rep = new CIMValueRep();

}

inline void _toXml(Array<Sint8>& out, Boolean x) { _toString(out, x); }

CIMValue::CIMValue(CIMType type, Boolean isArray, Uint32 arraySize)

inline void _toMof(Array<Sint8>& out, Boolean x) { _toString(out, x); }

inline void _integerToString(Array<Sint8>& out, Sint32 x)

{

char buffer[32];

_rep = new CIMValueRep();

sprintf(buffer, "%d", x);

setNullValue(type, isArray, arraySize);

out << (char*)buffer;

}

inline void _unsignedIntegerToString(Array<Sint8>& out, Uint32 x)

CIMValue::CIMValue(Boolean x)

{

char buffer[32];

_rep = new CIMValueRep();

sprintf(buffer, "%u", x);

set(x);

out << (char*)buffer;

}

inline void _toString(Array<Sint8>& out, Uint8 x) { _unsignedIntegerToString(out, x); }

CIMValue::CIMValue(Uint8 x)

inline void _toXml(Array<Sint8>& out, Uint8 x) { _toString(out, x); }

inline void _toMof(Array<Sint8>& out, Uint8 x) { _toString(out, x); }

inline void _toString(Array<Sint8>& out, Sint8 x) { _integerToString(out, x); }

inline void _toXml(Array<Sint8>& out, Sint8 x) { _toString(out, x); }

inline void _toMof(Array<Sint8>& out, Sint8 x) { _toString(out, x); }

inline void _toString(Array<Sint8>& out, Uint16 x) { _unsignedIntegerToString(out, x); }

inline void _toXml(Array<Sint8>& out, Uint16 x) { _toString(out, x); }

inline void _toMof(Array<Sint8>& out, Uint16 x) { _toString(out, x); }

inline void _toString(Array<Sint8>& out, Sint16 x) { _integerToString(out, x); }

inline void _toXml(Array<Sint8>& out, Sint16 x) { _toString(out, x); }

inline void _toMof(Array<Sint8>& out, Sint16 x) { _toString(out, x); }

inline void _toString(Array<Sint8>& out, Uint32 x) { _unsignedIntegerToString(out, x); }

inline void _toXml(Array<Sint8>& out, Uint32 x) { _toString(out, x); }

inline void _toMof(Array<Sint8>& out, Uint32 x) { _toString(out, x); }

inline void _toString(Array<Sint8>& out, Sint32 x) { _integerToString(out, x); }

inline void _toXml(Array<Sint8>& out, Sint32 x) { _toString(out, x); }

inline void _toMof(Array<Sint8>& out, Sint32 x) { _toString(out, x); }

inline void _toString(Array<Sint8>& out, Uint64 x)

{

char buffer[32]; // Should need 21 chars max

_rep = new CIMValueRep();

// I know I shouldn't put platform flags here, but the other was is too hard

set(x);

#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)

sprintf(buffer, "%I64u", x);

#else

sprintf(buffer, "%llu", x);

#endif

out << buffer;

}

inline void _toXml(Array<Sint8>& out, Uint64 x) { _toString(out, x); }

CIMValue::CIMValue(Sint8 x)

inline void _toMof(Array<Sint8>& out, Uint64 x) { _toString(out, x); }

inline void _toString(Array<Sint8>& out, Sint64 x)

{

char buffer[32]; // Should need 21 chars max

_rep = new CIMValueRep();

// I know I shouldn't put platform flags here, but the other was is too hard

set(x);

#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)

sprintf(buffer, "%I64d", x);

#else

sprintf(buffer, "%lld", x);

#endif

out << buffer;

}

inline void _toXml(Array<Sint8>& out, Sint64 x) { _toString(out, x); }

CIMValue::CIMValue(Uint16 x)

inline void _toMof(Array<Sint8>& out, Sint64 x) { _toString(out, x); }

void _toString(Array<Sint8>& out, Real64 x)

{

char buffer[128];

_rep = new CIMValueRep();

// %e gives '[-]m.dddddde+/-xx', which seems compatible with CIM/XML spec

set(x);

sprintf(buffer, "%e", x);

out << buffer;

}

inline void _toXml(Array<Sint8>& out, Real64 x) { _toString(out, x); }

CIMValue::CIMValue(Sint16 x)

inline void _toMof(Array<Sint8>& out, Real64 x) { _toString(out, x); }

inline void _toString(Array<Sint8>& out, Real32 x) { _toString(out, Real64(x)); }

inline void _toXml(Array<Sint8>& out, Real32 x) { _toString(out, x); }

inline void _toMof(Array<Sint8>& out, Real32 x) { _toString(out, x); }

inline void _toString(Array<Sint8>& out, Char16 x)

{

// ATTN: How to convert 16-bit characters to printable form?

_rep = new CIMValueRep();

out.append(Sint8(x));

set(x);

}

inline void _toXml(Array<Sint8>& out, Char16 x)

CIMValue::CIMValue(Uint32 x)

{

XmlWriter::appendSpecial(out, x);

_rep = new CIMValueRep();

set(x);

}

inline void _toMof(Array<Sint8>& out, Char16 x)

CIMValue::CIMValue(Sint32 x)

{

XmlWriter::appendSpecial(out, x);

_rep = new CIMValueRep();

set(x);

}

inline void _toString(Array<Sint8>& out, const String& x)

CIMValue::CIMValue(Uint64 x)

{

out << x;

_rep = new CIMValueRep();

set(x);

}

inline void _toXml(Array<Sint8>& out, const String& x)

CIMValue::CIMValue(Sint64 x)

{

XmlWriter::appendSpecial(out, x);

_rep = new CIMValueRep();

set(x);

}

/** _toMof Internal function to convert the string back

CIMValue::CIMValue(Real32 x)

to MOF format and output it.

The conversions are:

\b // \x0008: backspace BS

\t // \x0009: horizontal tab HT

\n // \x000A: linefeed LF

\f // \x000C: form feed FF

\r // \x000D: carriage return CR

\" // \x0022: double quote "

\� // \x0027: single quote '

\\ // \x005C: backslash \

\x<hex> // where <hex> is one to four hex digits

\X<hex> // where <hex> is one to four hex digits

/* ATTN:KS - We need to account for characters greater than x'7f

inline void _toMof(Array<Sint8>& out, const String& x)

{

out << "\"";

_rep = new CIMValueRep();

const Char16* tmp = x.getData();

set(x);

char c;

}

while ((c = *tmp++))

{

switch (c)

{

case '\\':

out.append("\\\\",2);

break;

case '\b':

CIMValue::CIMValue(Real64 x)

out.append("\\b",2);

{

break;

_rep = new CIMValueRep();

set(x);

}

case '\t':

CIMValue::CIMValue(const Char16& x)

out.append("\\t",2);

{

break;

_rep = new CIMValueRep();

set(x);

}

case '\n':

CIMValue::CIMValue(const String& x)

out.append("\\n",2);

{

break;

_rep = new CIMValueRep();

set(x);

}

case '\f':

CIMValue::CIMValue(const CIMDateTime& x)

out.append("\\f",2);

{

break;

_rep = new CIMValueRep();

set(x);

}

case '\r':

CIMValue::CIMValue(const CIMObjectPath& x)

out.append("\\r",2);

{

break;

_rep = new CIMValueRep();

set(x);

}

/* case '\'':

CIMValue::CIMValue(const CIMObject& x)

out.append("\\'", 2);

{

break;*/

_rep = new CIMValueRep();

AutoPtr<CIMValueRep> rep(_rep);

case '"':

set(x);

out.append("\\\"", 2);

break;

default:

rep.release();

out.append(Sint8(c));

}

CIMValue::CIMValue(const Array<Boolean>& x)

out << "\"";

{

_rep = new CIMValueRep();

set(x);

}

inline void _toString(Array<Sint8>& out, const CIMDateTime& x)

CIMValue::CIMValue(const Array<Uint8>& x)

{

out << x.getString();

_rep = new CIMValueRep();

set(x);

}

inline void _toXml(Array<Sint8>& out, const CIMDateTime& x) { _toString(out, x); }

CIMValue::CIMValue(const Array<Sint8>& x)

inline void _toMof(Array<Sint8>& out, const CIMDateTime& x) { _toString(out, x); }

inline void _toString(Array<Sint8>& out, const CIMReference& x)

{

out << x.toString();

_rep = new CIMValueRep();

set(x);

}

inline void _toXml(Array<Sint8>& out, const CIMReference& x)

CIMValue::CIMValue(const Array<Uint16>& x)

{

x.toXml(out);

_rep = new CIMValueRep();

set(x);

}

inline void _toMof(Array<Sint8>& out, const CIMReference& x)

CIMValue::CIMValue(const Array<Sint16>& x)

{

x.toMof(out);

_rep = new CIMValueRep();

set(x);

}

template<class T>

CIMValue::CIMValue(const Array<Uint32>& x)

void _toString(Array<Sint8>& out, const T* p, Uint32 size)

{

while (size--)

{

_toString(out, *p++);

_rep = new CIMValueRep();

out << " ";

set(x);

}

void _toXml(Array<Sint8>& out, const CIMReference* p, Uint32 size)

CIMValue::CIMValue(const Array<Sint32>& x)

{

out << "<VALUE.REFARRAY>\n";

_rep = new CIMValueRep();

while (size--)

set(x);

{

_toXml(out, *p++);

}

out << "</VALUE.REFARRAY>\n";

}

template<class T>

CIMValue::CIMValue(const Array<Uint64>& x)

void _toXml(Array<Sint8>& out, const T* p, Uint32 size)

{

out << "<VALUE.ARRAY>\n";

_rep = new CIMValueRep();

set(x);

}

while (size--)

CIMValue::CIMValue(const Array<Sint64>& x)

{

out << "<VALUE>";

_rep = new CIMValueRep();

set(x);

_toXml(out, *p++);

out << "</VALUE>\n";

}

out << "</VALUE.ARRAY>\n";

CIMValue::CIMValue(const Array<Real32>& x)

{

_rep = new CIMValueRep();

set(x);

}

/** _toMof Array -

arrayInitializer = "{" constantValue*( "," constantValue)"}"

CIMValue::CIMValue(const Array<Real64>& x)

template<class T>

void _toMof(Array<Sint8>& out, const T* p, Uint32 size)

{

Boolean isFirstEntry = true;

// if there are any entries in the array output them

if (size)

{

out << "{";

_rep = new CIMValueRep();

while (size--)

set(x);

{

// Put comma on all but first entry.

if (!isFirstEntry)

{

out << ", ";

}

isFirstEntry = false;

_toMof(out, *p++);

}

out << "}";

CIMValue::CIMValue(const Array<Char16>& x)

{

_rep = new CIMValueRep();

set(x);

}

CIMValue::CIMValue(const Array<String>& x)

{

_rep = new CIMValueRep();

set(x);

}

////////////////////////////////////////////////////////////////////////////////

CIMValue::CIMValue(const Array<CIMDateTime>& x)

{

// CIMValue

_rep = new CIMValueRep();

set(x);

////////////////////////////////////////////////////////////////////////////////

}

CIMValue::CIMValue()

CIMValue::CIMValue(const Array<CIMObjectPath>& x)

{

_init();

_rep = new CIMValueRep();

set(x);

}

CIMValue::CIMValue(CIMType type, Boolean isArray, Uint32 arraySize)

CIMValue::CIMValue(const Array<CIMObject>& x)

{

_init();

_rep = new CIMValueRep();

setNullValue(type, isArray, arraySize);

AutoPtr<CIMValueRep> rep(_rep);

set(x);

rep.release();

}

CIMValue::CIMValue(const CIMValue& x)

{

_init();

_rep = new CIMValueRep();

assign(x);

}

CIMValue::~CIMValue()

{

clear();

delete _rep;

}

CIMValue& CIMValue::operator=(const CIMValue& x)

{

assign(x);

return *this;

}

void CIMValue::assign(const CIMValue& x)

Line 466

Line 379

clear();

_type = x._type;

_rep->_type = x._rep->_type;

_isArray = x._isArray;

_rep->_isArray = x._rep->_isArray;

_isNull = x._isNull;

_rep->_isNull = x._rep->_isNull;

_u._voidPtr = 0;

if (_isArray)

if (_rep->_isArray)

{

switch (_type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

_Inc(_u._booleanArray = x._u._booleanArray);

_rep->_u._booleanArray =

new Array<Boolean>(*(x._rep->_u._booleanArray));

break;

case CIMType::UINT8:

case CIMTYPE_UINT8:

_Inc(_u._uint8Array = x._u._uint8Array);

_rep->_u._uint8Array =

new Array<Uint8>(*(x._rep->_u._uint8Array));

break;

case CIMType::SINT8:

case CIMTYPE_SINT8:

_Inc(_u._sint8Array = x._u._sint8Array);

_rep->_u._sint8Array =

new Array<Sint8>(*(x._rep->_u._sint8Array));

break;

case CIMType::UINT16:

case CIMTYPE_UINT16:

_Inc(_u._uint16Array = x._u._uint16Array);

_rep->_u._uint16Array =

new Array<Uint16>(*(x._rep->_u._uint16Array));

break;

case CIMType::SINT16:

case CIMTYPE_SINT16:

_Inc(_u._sint16Array = x._u._sint16Array);

_rep->_u._sint16Array =

new Array<Sint16>(*(x._rep->_u._sint16Array));

break;

case CIMType::UINT32:

case CIMTYPE_UINT32:

_Inc(_u._uint32Array = x._u._uint32Array);

_rep->_u._uint32Array =

new Array<Uint32>(*(x._rep->_u._uint32Array));

break;

case CIMType::SINT32:

case CIMTYPE_SINT32:

_Inc(_u._sint32Array = x._u._sint32Array);

_rep->_u._sint32Array =

new Array<Sint32>(*(x._rep->_u._sint32Array));

break;

case CIMType::UINT64:

case CIMTYPE_UINT64:

_Inc(_u._uint64Array = x._u._uint64Array);

_rep->_u._uint64Array =

new Array<Uint64>(*(x._rep->_u._uint64Array));

break;

case CIMType::SINT64:

case CIMTYPE_SINT64:

_Inc(_u._sint64Array = x._u._sint64Array);

_rep->_u._sint64Array =

new Array<Sint64>(*(x._rep->_u._sint64Array));

break;

case CIMType::REAL32:

case CIMTYPE_REAL32:

_Inc(_u._real32Array = x._u._real32Array);

_rep->_u._real32Array =

new Array<Real32>(*(x._rep->_u._real32Array));

break;

case CIMType::REAL64:

case CIMTYPE_REAL64:

_Inc(_u._real64Array = x._u._real64Array);

_rep->_u._real64Array =

new Array<Real64>(*(x._rep->_u._real64Array));

break;

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

_Inc(_u._char16Array = x._u._char16Array);

_rep->_u._char16Array =

new Array<Char16>(*(x._rep->_u._char16Array));

break;

case CIMType::STRING:

case CIMTYPE_STRING:

_Inc(_u._stringArray = x._u._stringArray);

_rep->_u._stringArray =

new Array<String>(*(x._rep->_u._stringArray));

break;

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

_Inc(_u._dateTimeArray = x._u._dateTimeArray);

_rep->_u._dateTimeArray =

new Array<CIMDateTime>(*(x._rep->_u._dateTimeArray));

break;

case CIMType::REFERENCE:

case CIMTYPE_REFERENCE:

_Inc(_u._referenceArray = x._u._referenceArray);

_rep->_u._referenceArray =

new Array<CIMObjectPath>(*(x._rep->_u._referenceArray));

break;

case CIMTYPE_OBJECT:

// Clone the object array

_rep->_u._objectArray = new Array<CIMObject>();

for (Uint32 i = 0, n = x._rep->_u._objectArray->size();

i < n; i++)

{

// Encountering an uninitialized CIMObject here would

// indicate a Pegasus bug rather than improper use of the

// CIMValue class

PEGASUS_ASSERT(

!(*(x._rep->_u._objectArray))[i].isUninitialized());

_rep->_u._objectArray->append(

(*(x._rep->_u._objectArray))[i].clone());

}

break;

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(false);

}

else

{

switch (_type)

switch (_rep->_type)

{

case CIMType::NONE:

case CIMTYPE_BOOLEAN:

_rep->_u._booleanValue = x._rep->_u._booleanValue;

break;

case CIMType::BOOLEAN:

case CIMTYPE_UINT8:

_u._booleanValue = x._u._booleanValue;

_rep->_u._uint8Value = x._rep->_u._uint8Value;

break;

case CIMType::UINT8:

case CIMTYPE_SINT8:

_u._uint8Value = x._u._uint8Value;

_rep->_u._sint8Value = x._rep->_u._sint8Value;

break;

case CIMType::SINT8:

case CIMTYPE_UINT16:

_u._sint8Value = x._u._sint8Value;

_rep->_u._uint16Value = x._rep->_u._uint16Value;

break;

case CIMType::UINT16:

case CIMTYPE_SINT16:

_u._uint16Value = x._u._uint16Value;

_rep->_u._sint16Value = x._rep->_u._sint16Value;

break;

case CIMType::SINT16:

case CIMTYPE_UINT32:

_u._sint16Value = x._u._sint16Value;

_rep->_u._uint32Value = x._rep->_u._uint32Value;

break;

case CIMType::UINT32:

case CIMTYPE_SINT32:

_u._uint32Value = x._u._uint32Value;

_rep->_u._sint32Value = x._rep->_u._sint32Value;

break;

case CIMType::SINT32:

case CIMTYPE_UINT64:

_u._sint32Value = x._u._sint32Value;

_rep->_u._uint64Value = x._rep->_u._uint64Value;

break;

case CIMType::UINT64:

case CIMTYPE_SINT64:

_u._uint64Value = x._u._uint64Value;

_rep->_u._sint64Value = x._rep->_u._sint64Value;

break;

case CIMType::SINT64:

case CIMTYPE_REAL32:

_u._sint64Value = x._u._sint64Value;

_rep->_u._real32Value = x._rep->_u._real32Value;

break;

case CIMType::REAL32:

case CIMTYPE_REAL64:

_u._real32Value = x._u._real32Value;

_rep->_u._real64Value = x._rep->_u._real64Value;

break;

case CIMType::REAL64:

case CIMTYPE_CHAR16:

_u._real64Value = x._u._real64Value;

_rep->_u._char16Value = x._rep->_u._char16Value;

break;

case CIMType::CHAR16:

case CIMTYPE_STRING:

_u._char16Value = x._u._char16Value;

_rep->_u._stringValue = new String(*(x._rep->_u._stringValue));

break;

case CIMType::STRING:

case CIMTYPE_DATETIME:

_u._stringValue = new String(*(x._u._stringValue));

_rep->_u._dateTimeValue =

new CIMDateTime(*(x._rep->_u._dateTimeValue));

break;

case CIMType::DATETIME:

case CIMTYPE_REFERENCE:

_u._dateTimeValue = new CIMDateTime(*(x._u._dateTimeValue));

_rep->_u._referenceValue =

new CIMObjectPath(*(x._rep->_u._referenceValue));

break;

case CIMType::REFERENCE:

case CIMTYPE_OBJECT:

_u._referenceValue

if (x._rep->_u._objectValue->isUninitialized())

= new CIMReference(*(x._u._referenceValue));

{

_rep->_u._objectValue = new CIMObject();

}

else

{

_rep->_u._objectValue =

new CIMObject(x._rep->_u._objectValue->clone());

}

break;

// Should never get here. testing complete enum

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(false);

}

Uint32 CIMValue::getArraySize() const

void CIMValue::clear()

{

if (!_isArray)

if (_rep->_isArray)

return 0;

switch (_type)

{

case CIMType::NONE:

switch (_rep->_type)

return 0;

{

case CIMTYPE_BOOLEAN:

delete _rep->_u._booleanArray;

break;

case CIMType::BOOLEAN:

case CIMTYPE_UINT8:

return _u._booleanArray->size;

delete _rep->_u._uint8Array;

break;

case CIMType::UINT8:

case CIMTYPE_SINT8:

return _u._uint8Array->size;

delete _rep->_u._sint8Array;

break;

case CIMType::SINT8:

case CIMTYPE_UINT16:

return _u._sint8Array->size;

delete _rep->_u._uint16Array;

break;

case CIMType::UINT16:

case CIMTYPE_SINT16:

return _u._uint16Array->size;

delete _rep->_u._sint16Array;

break;

case CIMType::SINT16:

case CIMTYPE_UINT32:

return _u._sint16Array->size;

delete _rep->_u._uint32Array;

break;

case CIMType::UINT32:

case CIMTYPE_SINT32:

return _u._uint32Array->size;

delete _rep->_u._sint32Array;

break;

case CIMType::SINT32:

case CIMTYPE_UINT64:

return _u._sint32Array->size;

delete _rep->_u._uint64Array;

break;

case CIMType::UINT64:

case CIMTYPE_SINT64:

return _u._uint64Array->size;

delete _rep->_u._sint64Array;

break;

case CIMType::SINT64:

case CIMTYPE_REAL32:

return _u._sint64Array->size;

delete _rep->_u._real32Array;

break;

case CIMType::REAL32:

case CIMTYPE_REAL64:

return _u._real32Array->size;

delete _rep->_u._real64Array;

break;

case CIMType::REAL64:

case CIMTYPE_CHAR16:

return _u._real64Array->size;

delete _rep->_u._char16Array;

break;

case CIMType::CHAR16:

case CIMTYPE_STRING:

return _u._char16Array->size;

delete _rep->_u._stringArray;

break;

case CIMType::STRING:

case CIMTYPE_DATETIME:

return _u._stringArray->size;

delete _rep->_u._dateTimeArray;

break;

case CIMType::DATETIME:

case CIMTYPE_REFERENCE:

return _u._dateTimeArray->size;

delete _rep->_u._referenceArray;

break;

case CIMType::REFERENCE:

case CIMTYPE_OBJECT:

return _u._referenceArray->size;

delete _rep->_u._objectArray;

break;

// Should never get here. switch on complete enum

default:

throw CIMValueInvalidType();

}

// Unreachable!

default:

PEGASUS_ASSERT(false);

return 0;

}

//ATTN: P1 KS Problem with Compiler when I added the defaults to clear, the compiler

else

// gets an exception very early. Disabled the exceptions to keep compiler running for

// the minute. Note that the case statement is not complete. None missing.

void CIMValue::clear()

{

// ATTN: KS P1 should we be setting NULL=true here????. Right now it only

// clears the value component. Note that the last thing we do is init

// and that does the isNull=false.

if (_isArray)

{

switch (_type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

_Dec(_u._booleanArray);

case CIMTYPE_UINT8:

break;

case CIMTYPE_SINT8:

case CIMTYPE_UINT16:

case CIMType::UINT8:

case CIMTYPE_SINT16:

_Dec(_u._uint8Array);

case CIMTYPE_UINT32:

break;

case CIMTYPE_SINT32:

case CIMTYPE_UINT64:

case CIMType::SINT8:

case CIMTYPE_SINT64:

_Dec(_u._sint8Array);

case CIMTYPE_REAL32:

break;

case CIMTYPE_REAL64:

case CIMTYPE_CHAR16:

case CIMType::UINT16:

_Dec(_u._uint16Array);

break;

case CIMType::SINT16:

_Dec(_u._sint16Array);

break;

case CIMType::UINT32:

case CIMTYPE_STRING:

_Dec(_u._uint32Array);

delete _rep->_u._stringValue;

break;

case CIMType::SINT32:

case CIMTYPE_DATETIME:

_Dec(_u._sint32Array);

delete _rep->_u._dateTimeValue;

break;

case CIMType::UINT64:

case CIMTYPE_REFERENCE:

_Dec(_u._uint64Array);

delete _rep->_u._referenceValue;

break;

case CIMType::SINT64:

case CIMTYPE_OBJECT:

_Dec(_u._sint64Array);

delete _rep->_u._objectValue;

break;

case CIMType::REAL32:

default:

_Dec(_u._real32Array);

PEGASUS_ASSERT(false);

break;

case CIMType::REAL64:

_Dec(_u._real64Array);

break;

case CIMType::CHAR16:

_Dec(_u._char16Array);

break;

case CIMType::STRING:

_Dec(_u._stringArray);

break;

case CIMType::DATETIME:

_Dec(_u._dateTimeArray);

break;

case CIMType::REFERENCE:

_Dec(_u._referenceArray);

break;

//default:

//throw CIMValueInvalidType();

}

else

{

switch (_type)

{

case CIMType::BOOLEAN:

case CIMType::UINT8:

case CIMType::SINT8:

case CIMType::UINT16:

case CIMType::SINT16:

case CIMType::UINT32:

case CIMType::SINT32:

case CIMType::UINT64:

case CIMType::SINT64:

case CIMType::REAL32:

case CIMType::REAL64:

case CIMType::CHAR16:

break;

case CIMType::STRING:

delete _u._stringValue;

break;

case CIMType::DATETIME:

delete _u._dateTimeValue;

break;

case CIMType::REFERENCE:

delete _u._referenceValue;

break;

//default:

//throw CIMValueInvalidType();

}

_init();

_rep->reset();

}

void CIMValue::toXml(Array<Sint8>& out, Boolean forceTag) const

Boolean CIMValue::typeCompatible(const CIMValue& x) const

{

/* If the CIMValue is Null, no element is returned.

return (_rep->_type == x._rep->_type &&

Note that it output absolutely nothing. This works for

_rep->_isArray == x._rep->_isArray);

everything except qualifiers where the value tag is required in

// getArraySize() == x.getArraySize());

any case per the XML specification

if (_isNull)

{

if (forceTag)

if (_isArray)

out << "<VALUE.ARRAY></VALUE.ARRAY>\n";

else

out << "<VALUE></VALUE>\n";

return;

}

if (_isArray)

{

switch (_type)

{

case CIMType::BOOLEAN:

{

// ATTN-RK-P3-20020220: Why can't this just use

// _toXml(out, _u._booleanArray->data(), _u._booleanArray->size);

// like everybody else?

out << "<VALUE.ARRAY>\n";

for (Uint32 i = 0, n = _u._booleanArray->size; i < n; i++)

Boolean CIMValue::isArray() const

{

out << "<VALUE>";

return _rep->_isArray;

_toXml(out, Boolean(_u._booleanArray->data()[i]));

out << "</VALUE>\n";

}

out << "</VALUE.ARRAY>\n";

Boolean CIMValue::isNull() const

break;

{

return _rep->_isNull;

}

case CIMType::UINT8:

Uint32 CIMValue::getArraySize() const

_toXml(out, _u._uint8Array->data(), _u._uint8Array->size);

{

break;

if (!_rep->_isArray)

return 0;

case CIMType::SINT8:

_toXml(out, _u._sint8Array->data(), _u._sint8Array->size);

break;

case CIMType::UINT16:

_toXml(out, _u._uint16Array->data(), _u._uint16Array->size);

break;

case CIMType::SINT16:

_toXml(out, _u._sint16Array->data(), _u._sint16Array->size);

break;

case CIMType::UINT32:

_toXml(out, _u._uint32Array->data(), _u._uint32Array->size);

break;

case CIMType::SINT32:

_toXml(out, _u._sint32Array->data(), _u._sint32Array->size);

break;

case CIMType::UINT64:

_toXml(out, _u._uint64Array->data(), _u._uint64Array->size);

break;

case CIMType::SINT64:

_toXml(out, _u._sint64Array->data(), _u._sint64Array->size);

break;

case CIMType::REAL32:

_toXml(out, _u._real32Array->data(), _u._real32Array->size);

break;

case CIMType::REAL64:

_toXml(out, _u._real64Array->data(), _u._real64Array->size);

break;

case CIMType::CHAR16:

_toXml(out, _u._char16Array->data(), _u._char16Array->size);

break;

case CIMType::STRING:

switch (_rep->_type)

_toXml(out, _u._stringArray->data(), _u._stringArray->size);

{

case CIMTYPE_BOOLEAN:

return _rep->_u._booleanArray->size();

break;

case CIMType::DATETIME:

case CIMTYPE_UINT8:

_toXml(out, _u._dateTimeArray->data(), _u._dateTimeArray->size);

return _rep->_u._uint8Array->size();

break;

case CIMType::REFERENCE:

case CIMTYPE_SINT8:

_toXml(out, _u._referenceArray->data(),

return _rep->_u._sint8Array->size();

_u._referenceArray->size);

break;

default:

case CIMTYPE_UINT16:

throw CIMValueInvalidType();

return _rep->_u._uint16Array->size();

}

else if (_type == CIMType::REFERENCE)

{

// Has to be separate because it uses VALUE.REFERENCE tag

_toXml(out, *_u._referenceValue);

}

else

{

out << "<VALUE>";

switch (_type)

{

case CIMType::BOOLEAN:

_toXml(out, Boolean(_u._booleanValue != 0));

break;

case CIMType::UINT8:

case CIMTYPE_SINT16:

_toXml(out, _u._uint8Value);

return _rep->_u._sint16Array->size();

break;

case CIMType::SINT8:

case CIMTYPE_UINT32:

_toXml(out, _u._sint8Value);

return _rep->_u._uint32Array->size();

break;

case CIMType::UINT16:

case CIMTYPE_SINT32:

_toXml(out, _u._uint16Value);

return _rep->_u._sint32Array->size();

break;

case CIMType::SINT16:

case CIMTYPE_UINT64:

_toXml(out, _u._sint16Value);

return _rep->_u._uint64Array->size();

break;

case CIMType::UINT32:

case CIMTYPE_SINT64:

_toXml(out, _u._uint32Value);

return _rep->_u._sint64Array->size();

break;

case CIMType::SINT32:

case CIMTYPE_REAL32:

_toXml(out, _u._sint32Value);

return _rep->_u._real32Array->size();

break;

case CIMType::UINT64:

case CIMTYPE_REAL64:

_toXml(out, _u._uint64Value);

return _rep->_u._real64Array->size();

break;

case CIMType::SINT64:

case CIMTYPE_CHAR16:

_toXml(out, _u._sint64Value);

return _rep->_u._char16Array->size();

break;

case CIMType::REAL32:

case CIMTYPE_STRING:

_toXml(out, _u._real32Value);

return _rep->_u._stringArray->size();

break;

case CIMType::REAL64:

case CIMTYPE_DATETIME:

_toXml(out, _u._real64Value);

return _rep->_u._dateTimeArray->size();

break;

case CIMType::CHAR16:

case CIMTYPE_REFERENCE:

_toXml(out, Char16(_u._char16Value));

return _rep->_u._referenceArray->size();

break;

case CIMType::STRING:

case CIMTYPE_OBJECT:

_toXml(out, *_u._stringValue);

return _rep->_u._objectArray->size();

break;

case CIMType::DATETIME:

//default: // Handled below

_toXml(out, *_u._dateTimeValue);

break;

default:

throw CIMValueInvalidType();

}

out << "</VALUE>\n";

// Unreachable!

}

PEGASUS_ASSERT(false);

PEGASUS_UNREACHABLE( return 0; )

}

String CIMValue::toXml(Boolean forceTag) const

CIMType CIMValue::getType() const

{

Array<Sint8> out;

return CIMType(_rep->_type);

toXml(out, forceTag);

out.append('\0');

return String(out.getData());

}

void CIMValue::toMof(Array<Sint8>& out) const

void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize)

{

// if the CIMValue is Null we return nothing.

// The alternative is to return the Null indicator.

if (_isNull)

{

out << "null";

clear();

return ;

}

if (_isArray)

if (isArray)

{

switch (_type)

{

case CIMType::BOOLEAN:

switch (type)

{

_toMof(out, _u._booleanArray->data(), _u._booleanArray->size);

case CIMTYPE_BOOLEAN:

set(Array<Boolean>(arraySize));

break;

}

case CIMType::UINT8:

case CIMTYPE_UINT8:

_toMof(out, _u._uint8Array->data(), _u._uint8Array->size);

set(Array<Uint8>(arraySize));

break;

case CIMTYPE_SINT8:

set(Array<Sint8>(arraySize));

break;

case CIMType::SINT8:

case CIMTYPE_UINT16:

_toMof(out, _u._sint8Array->data(), _u._sint8Array->size);

set(Array<Uint16>(arraySize));

break;

case CIMType::UINT16:

case CIMTYPE_SINT16:

_toMof(out, _u._uint16Array->data(), _u._uint16Array->size);

set(Array<Sint16>(arraySize));

break;

case CIMType::SINT16:

case CIMTYPE_UINT32:

_toMof(out, _u._sint16Array->data(), _u._sint16Array->size);

set(Array<Uint32>(arraySize));

break;

case CIMType::UINT32:

case CIMTYPE_SINT32:

_toMof(out, _u._uint32Array->data(), _u._uint32Array->size);

set(Array<Sint32>(arraySize));

break;

case CIMType::SINT32:

case CIMTYPE_UINT64:

_toMof(out, _u._sint32Array->data(), _u._sint32Array->size);

set(Array<Uint64>(arraySize));

break;

case CIMType::UINT64:

case CIMTYPE_SINT64:

_toMof(out, _u._uint64Array->data(), _u._uint64Array->size);

set(Array<Sint64>(arraySize));

break;

case CIMType::SINT64:

case CIMTYPE_REAL32:

_toMof(out, _u._sint64Array->data(), _u._sint64Array->size);

set(Array<Real32>(arraySize));

break;

case CIMType::REAL32:

case CIMTYPE_REAL64:

_toMof(out, _u._real32Array->data(), _u._real32Array->size);

set(Array<Real64>(arraySize));

break;

case CIMType::REAL64:

case CIMTYPE_CHAR16:

_toMof(out, _u._real64Array->data(), _u._real64Array->size);

set(Array<Char16>(arraySize));

break;

case CIMType::CHAR16:

case CIMTYPE_STRING:

_toMof(out, _u._char16Array->data(), _u._char16Array->size);

set(Array<String>(arraySize));

break;

case CIMType::STRING:

case CIMTYPE_DATETIME:

_toMof(out, _u._stringArray->data(), _u._stringArray->size);

set(Array<CIMDateTime>(arraySize));

break;

case CIMType::DATETIME:

case CIMTYPE_REFERENCE:

_toMof(out, _u._dateTimeArray->data(),

set(Array<CIMObjectPath>(arraySize));

_u._dateTimeArray->size);

break;

case CIMType::REFERENCE:

case CIMTYPE_OBJECT:

_toMof(out, _u._referenceArray->data(),

set(Array<CIMObject>(arraySize));

_u._referenceArray->size);

break;

default:

throw CIMValueInvalidType();

throw TypeMismatchException();

}

else

{

switch (_type)

switch (type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

_toMof(out, Boolean(_u._booleanValue != 0));

set(false);

break;

case CIMType::UINT8:

case CIMTYPE_UINT8:

_toMof(out, _u._uint8Value);

set(Uint8(0));

break;

case CIMType::SINT8:

case CIMTYPE_SINT8:

_toMof(out, _u._sint8Value);

set(Sint8(0));

break;

case CIMType::UINT16:

case CIMTYPE_UINT16:

_toMof(out, _u._uint16Value);

set(Uint16(0));

break;

case CIMType::SINT16:

case CIMTYPE_SINT16:

_toMof(out, _u._sint16Value);

set(Sint16(0));

break;

case CIMType::UINT32:

case CIMTYPE_UINT32:

_toMof(out, _u._uint32Value);

set(Uint32(0));

break;

case CIMType::SINT32:

case CIMTYPE_SINT32:

_toMof(out, _u._sint32Value);

set(Sint32(0));

break;

case CIMType::UINT64:

case CIMTYPE_UINT64:

_toMof(out, _u._uint64Value);

set(Uint64(0));

break;

case CIMType::SINT64:

case CIMTYPE_SINT64:

_toMof(out, _u._sint64Value);

set(Sint64(0));

break;

case CIMType::REAL32:

case CIMTYPE_REAL32:

_toMof(out, _u._real32Value);

set(Real32(0.0));

break;

case CIMType::REAL64:

case CIMTYPE_REAL64:

_toMof(out, _u._real64Value);

set(Real64(0.0));

break;

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

_toMof(out, Char16(_u._char16Value));

set(Char16(0));

break;

case CIMType::STRING:

case CIMTYPE_STRING:

_toMof(out, *_u._stringValue);

set(String());

break;

case CIMTYPE_DATETIME:

set(CIMDateTime());

break;

case CIMType::DATETIME:

case CIMTYPE_REFERENCE:

_toMof(out, *_u._dateTimeValue);

set(CIMObjectPath());

break;

case CIMType::REFERENCE:

case CIMTYPE_OBJECT:

_toMof(out, *_u._referenceValue);

// Since we can't use set() with an uninitialized CIMObject(), and

// nothing else really makes sense, we duplicate the set() function

// here for an uninitialized object.

_rep->_u._objectValue = new CIMObject();

_rep->_type = CIMTYPE_OBJECT;

break;

default:

throw CIMValueInvalidType();

throw TypeMismatchException();

}

// Set the Null attribute. Note that this must be after the set

// because the set functions sets the _isNull.

void CIMValue::print( Boolean forceTag, PEGASUS_STD(ostream) &os) const

_rep->_isNull = true;

{

Array<Sint8> tmp;

toXml(tmp, forceTag);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

}

void CIMValue::set(Boolean x)

{

clear();

_u._booleanValue = (Uint8)x;

_rep->_u._booleanValue = (Uint8)x;

_type = CIMType::BOOLEAN;

_rep->_type = CIMTYPE_BOOLEAN;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Uint8 x)

{

clear();

_u._uint8Value = x;

_rep->_u._uint8Value = x;

_type = CIMType::UINT8;

_rep->_type = CIMTYPE_UINT8;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Sint8 x)

{

clear();

_u._sint8Value = x;

_rep->_u._sint8Value = x;

_type = CIMType::SINT8;

_rep->_type = CIMTYPE_SINT8;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Uint16 x)

{

clear();

_u._uint16Value = x;

_rep->_u._uint16Value = x;

_type = CIMType::UINT16;

_rep->_type = CIMTYPE_UINT16;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Sint16 x)

{

clear();

_u._sint16Value = x;

_rep->_u._sint16Value = x;

_type = CIMType::SINT16;

_rep->_type = CIMTYPE_SINT16;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Uint32 x)

{

clear();

_u._uint32Value = x;

_rep->_u._uint32Value = x;

_type = CIMType::UINT32;

_rep->_type = CIMTYPE_UINT32;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Sint32 x)

{

clear();

_u._sint32Value = x;

_rep->_u._sint32Value = x;

_type = CIMType::SINT32;

_rep->_type = CIMTYPE_SINT32;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Uint64 x)

{

clear();

_u._uint64Value = x;

_rep->_u._uint64Value = x;

_type = CIMType::UINT64;

_rep->_type = CIMTYPE_UINT64;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Sint64 x)

{

clear();

_u._sint64Value = x;

_rep->_u._sint64Value = x;

_type = CIMType::SINT64;

_rep->_type = CIMTYPE_SINT64;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Real32 x)

{

clear();

_u._real32Value = x;

_rep->_u._real32Value = x;

_type = CIMType::REAL32;

_rep->_type = CIMTYPE_REAL32;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Real64 x)

{

clear();

_u._real64Value = x;

_rep->_u._real64Value = x;

_type = CIMType::REAL64;

_rep->_type = CIMTYPE_REAL64;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const Char16& x)

{

clear();

_u._char16Value = x;

_rep->_u._char16Value = x;

_type = CIMType::CHAR16;

_rep->_type = CIMTYPE_CHAR16;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const String& x)

{

clear();

_u._stringValue = new String(x);

_rep->_u._stringValue = new String(x);

_type = CIMType::STRING;

_rep->_type = CIMTYPE_STRING;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const char* x)

void CIMValue::set(const CIMDateTime& x)

{

set(String(x));

clear();

_isNull = false;

_rep->_u._dateTimeValue = new CIMDateTime(x);

_rep->_type = CIMTYPE_DATETIME;

_rep->_isNull = false;

}

void CIMValue::set(const CIMDateTime& x)

void CIMValue::set(const CIMObjectPath& x)

{

clear();

_u._dateTimeValue = new CIMDateTime(x);

_rep->_u._referenceValue = new CIMObjectPath(x);

_type = CIMType::DATETIME;

_rep->_type = CIMTYPE_REFERENCE;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const CIMReference& x)

void CIMValue::set(const CIMObject& x)

{

clear();

_u._referenceValue = new CIMReference(x);

if (x.isUninitialized()) {

_type = CIMType::REFERENCE;

// Bug 3373, throw exception if uninitialized object is passed to set().

_isNull = false;

throw UninitializedObjectException();

}

else {

_rep->_u._objectValue = new CIMObject(x.clone());

}

_rep->_type = CIMTYPE_OBJECT;

_rep->_isNull = false;

}

void CIMValue::set(const Array<Boolean>& x)

{

clear();

_Inc(_u._booleanArray = x._rep);

_rep->_u._booleanArray = new Array<Boolean>(x);

_type = CIMType::BOOLEAN;

_rep->_type = CIMTYPE_BOOLEAN;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const Array<Uint8>& x)

{

clear();

_Inc(_u._uint8Array = x._rep);

_rep->_u._uint8Array = new Array<Uint8>(x);

_type = CIMType::UINT8;

_rep->_type = CIMTYPE_UINT8;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const Array<Sint8>& x)

{

clear();

_Inc(_u._sint8Array = x._rep);

_rep->_u._sint8Array = new Array<Sint8>(x);

_type = CIMType::SINT8;

_rep->_type = CIMTYPE_SINT8;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const Array<Uint16>& x)

{

clear();

_Inc(_u._uint16Array = x._rep);

_rep->_u._uint16Array = new Array<Uint16>(x);

_type = CIMType::UINT16;

_rep->_type = CIMTYPE_UINT16;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const Array<Sint16>& x)

{

clear();

_Inc(_u._sint16Array = x._rep);

_rep->_u._sint16Array = new Array<Sint16>(x);

_type = CIMType::SINT16;

_rep->_type = CIMTYPE_SINT16;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const Array<Uint32>& x)

{

clear();

_Inc(_u._uint32Array = x._rep);

_rep->_u._uint32Array = new Array<Uint32>(x);

_type = CIMType::UINT32;

_rep->_type = CIMTYPE_UINT32;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const Array<Sint32>& x)

{

clear();

_Inc(_u._sint32Array = x._rep);

_rep->_u._sint32Array = new Array<Sint32>(x);

_type = CIMType::SINT32;

_rep->_type = CIMTYPE_SINT32;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const Array<Uint64>& x)

{

clear();

_Inc(_u._uint64Array = x._rep);

_rep->_u._uint64Array = new Array<Uint64>(x);

_type = CIMType::UINT64;

_rep->_type = CIMTYPE_UINT64;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const Array<Sint64>& x)

{

clear();

_Inc(_u._sint64Array = x._rep);

_rep->_u._sint64Array = new Array<Sint64>(x);

_type = CIMType::SINT64;

_rep->_type = CIMTYPE_SINT64;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const Array<Real32>& x)

{

clear();

_Inc(_u._real32Array = x._rep);

_rep->_u._real32Array = new Array<Real32>(x);

_type = CIMType::REAL32;

_rep->_type = CIMTYPE_REAL32;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const Array<Real64>& x)

{

clear();

_Inc(_u._real64Array = x._rep);

_rep->_u._real64Array = new Array<Real64>(x);

_type = CIMType::REAL64;

_rep->_type = CIMTYPE_REAL64;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const Array<Char16>& x)

{

clear();

_Inc(_u._char16Array = x._rep);

_rep->_u._char16Array = new Array<Char16>(x);

_type = CIMType::CHAR16;

_rep->_type = CIMTYPE_CHAR16;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const Array<String>& x)

{

clear();

_Inc(_u._stringArray = x._rep);

_rep->_u._stringArray = new Array<String>(x);

_type = CIMType::STRING;

_rep->_type = CIMTYPE_STRING;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const Array<CIMDateTime>& x)

{

clear();

_Inc(_u._dateTimeArray = x._rep);

_rep->_u._dateTimeArray = new Array<CIMDateTime>(x);

_type = CIMType::DATETIME;

_rep->_type = CIMTYPE_DATETIME;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const Array<CIMReference>& x)

void CIMValue::set(const Array<CIMObjectPath>& x)

{

clear();

_Inc(_u._referenceArray = x._rep);

_rep->_u._referenceArray = new Array<CIMObjectPath>(x);

_type = CIMType::REFERENCE;

_rep->_type = CIMTYPE_REFERENCE;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const Array<CIMObject>& x)

{

clear();

// Copy the input value

AutoPtr<Array<CIMObject> > objectArray(new Array<CIMObject>());

for (Uint32 i = 0, n = x.size(); i < n; i++)

{

// Do not allow the value to contain an uninitialized CIMObject

if (x[i].isUninitialized())

{

throw UninitializedObjectException();

}

objectArray->append(x[i].clone());

}

_rep->_u._objectArray = objectArray.release();

_rep->_type = CIMTYPE_OBJECT;

_rep->_isArray = true;

_rep->_isNull = false;

}

void CIMValue::get(Boolean& x) const

{

if (_type != CIMType::BOOLEAN || _isArray)

if (_rep->_type != CIMTYPE_BOOLEAN || _rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _u._booleanValue != 0;

if (!_rep->_isNull)

x = _rep->_u._booleanValue != 0;

}

void CIMValue::get(Uint8& x) const

{

if (_type != CIMType::UINT8 || _isArray)

if (_rep->_type != CIMTYPE_UINT8 || _rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _u._uint8Value;

if (!_rep->_isNull)

x = _rep->_u._uint8Value;

}

void CIMValue::get(Sint8& x) const

{

if (_type != CIMType::SINT8 || _isArray)

if (_rep->_type != CIMTYPE_SINT8 || _rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _u._sint8Value;

if (!_rep->_isNull)

x = _rep->_u._sint8Value;

}

void CIMValue::get(Uint16& x) const

{

if (_type != CIMType::UINT16 || _isArray)

if (_rep->_type != CIMTYPE_UINT16 || _rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _u._uint16Value;

if (!_rep->_isNull)

x = _rep->_u._uint16Value;

}

void CIMValue::get(Sint16& x) const

{

if (_type != CIMType::SINT16 || _isArray)

if (_rep->_type != CIMTYPE_SINT16 || _rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _u._sint16Value;

if (!_rep->_isNull)

x = _rep->_u._sint16Value;

}

void CIMValue::get(Uint32& x) const

{

if (_type != CIMType::UINT32 || _isArray)

if (_rep->_type != CIMTYPE_UINT32 || _rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _u._uint32Value;

if (!_rep->_isNull)

x = _rep->_u._uint32Value;

}

void CIMValue::get(Sint32& x) const

{

if (_type != CIMType::SINT32 || _isArray)

if (_rep->_type != CIMTYPE_SINT32 || _rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _u._sint32Value;

if (!_rep->_isNull)

x = _rep->_u._sint32Value;

}

void CIMValue::get(Uint64& x) const

{

if (_type != CIMType::UINT64 || _isArray)

if (_rep->_type != CIMTYPE_UINT64 || _rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _u._uint64Value;

if (!_rep->_isNull)

x = _rep->_u._uint64Value;

}

void CIMValue::get(Sint64& x) const

{

if (_type != CIMType::SINT64 || _isArray)

if (_rep->_type != CIMTYPE_SINT64 || _rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _u._sint64Value;

if (!_rep->_isNull)

x = _rep->_u._sint64Value;

}

void CIMValue::get(Real32& x) const

{

if (_type != CIMType::REAL32 || _isArray)

if (_rep->_type != CIMTYPE_REAL32 || _rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _u._real32Value;

if (!_rep->_isNull)

x = _rep->_u._real32Value;

}

void CIMValue::get(Real64& x) const

{

if (_type != CIMType::REAL64 || _isArray)

if (_rep->_type != CIMTYPE_REAL64 || _rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _u._real64Value;

if (!_rep->_isNull)

x = _rep->_u._real64Value;

}

void CIMValue::get(Char16& x) const

{

if (_type != CIMType::CHAR16 || _isArray)

if (_rep->_type != CIMTYPE_CHAR16 || _rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _u._char16Value;

if (!_rep->_isNull)

x = _rep->_u._char16Value;

}

void CIMValue::get(String& x) const

{

if (_type != CIMType::STRING || _isArray)

if (_rep->_type != CIMTYPE_STRING || _rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_u._stringValue;

if (!_rep->_isNull)

x = *_rep->_u._stringValue;

}

void CIMValue::get(CIMDateTime& x) const

{

if (_type != CIMType::DATETIME || _isArray)

if (_rep->_type != CIMTYPE_DATETIME || _rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_u._dateTimeValue;

if (!_rep->_isNull)

x = *_rep->_u._dateTimeValue;

}

void CIMValue::get(CIMReference& x) const

void CIMValue::get(CIMObjectPath& x) const

{

if (_type != CIMType::REFERENCE || _isArray)

if (_rep->_type != CIMTYPE_REFERENCE || _rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_u._referenceValue;

if (!_rep->_isNull)

x = *_rep->_u._referenceValue;

}

void CIMValue::get(CIMObject& x) const

{

if (_rep->_type != CIMTYPE_OBJECT || _rep->_isArray)

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._objectValue;

}

void CIMValue::get(Array<Boolean>& x) const

{

if (_type != CIMType::BOOLEAN || !_isArray)

if (_rep->_type != CIMTYPE_BOOLEAN || !_rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x.set(_u._booleanArray);

if (!_rep->_isNull)

x = *_rep->_u._booleanArray;

}

void CIMValue::get(Array<Uint8>& x) const

{

if (_type != CIMType::UINT8 || !_isArray)

if (_rep->_type != CIMTYPE_UINT8 || !_rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x.set(_u._uint8Array);

if (!_rep->_isNull)

x = *_rep->_u._uint8Array;

}

void CIMValue::get(Array<Sint8>& x) const

{

if (_type != CIMType::SINT8 || !_isArray)

if (_rep->_type != CIMTYPE_SINT8 || !_rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x.set(_u._sint8Array);

if (!_rep->_isNull)

x = *_rep->_u._sint8Array;

}

void CIMValue::get(Array<Uint16>& x) const

{

if (_type != CIMType::UINT16 || !_isArray)

if (_rep->_type != CIMTYPE_UINT16 || !_rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x.set(_u._uint16Array);

if (!_rep->_isNull)

x = *_rep->_u._uint16Array;

}

void CIMValue::get(Array<Sint16>& x) const

{

if (_type != CIMType::SINT16 || !_isArray)

if (_rep->_type != CIMTYPE_SINT16 || !_rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x.set(_u._sint16Array);

if (!_rep->_isNull)

x = *_rep->_u._sint16Array;

}

void CIMValue::get(Array<Uint32>& x) const

{

if (_type != CIMType::UINT32 || !_isArray)

if (_rep->_type != CIMTYPE_UINT32 || !_rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x.set(_u._uint32Array);

if (!_rep->_isNull)

x = *_rep->_u._uint32Array;

}

void CIMValue::get(Array<Sint32>& x) const

{

if (_type != CIMType::SINT32 || !_isArray)

if (_rep->_type != CIMTYPE_SINT32 || !_rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x.set(_u._sint32Array);

if (!_rep->_isNull)

x = *_rep->_u._sint32Array;

}

void CIMValue::get(Array<Uint64>& x) const

{

if (_type != CIMType::UINT64 || !_isArray)

if (_rep->_type != CIMTYPE_UINT64 || !_rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x.set(_u._uint64Array);

if (!_rep->_isNull)

x = *_rep->_u._uint64Array;

}

void CIMValue::get(Array<Sint64>& x) const

{

if (_type != CIMType::SINT64 || !_isArray)

if (_rep->_type != CIMTYPE_SINT64 || !_rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x.set(_u._sint64Array);

if (!_rep->_isNull)

x = *_rep->_u._sint64Array;

}

void CIMValue::get(Array<Real32>& x) const

{

if (_type != CIMType::REAL32 || !_isArray)

if (_rep->_type != CIMTYPE_REAL32 || !_rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x.set(_u._real32Array);

if (!_rep->_isNull)

x = *_rep->_u._real32Array;

}

void CIMValue::get(Array<Real64>& x) const

{

if (_type != CIMType::REAL64 || !_isArray)

if (_rep->_type != CIMTYPE_REAL64 || !_rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x.set(_u._real64Array);

if (!_rep->_isNull)

x = *_rep->_u._real64Array;

}

void CIMValue::get(Array<Char16>& x) const

{

if (_type != CIMType::CHAR16 || !_isArray)

if (_rep->_type != CIMTYPE_CHAR16 || !_rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x.set(_u._char16Array);

if (!_rep->_isNull)

x = *_rep->_u._char16Array;

}

void CIMValue::get(Array<String>& x) const

{

if (_type != CIMType::STRING || !_isArray)

if (_rep->_type != CIMTYPE_STRING || !_rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x.set(_u._stringArray);

if (!_rep->_isNull)

x = *_rep->_u._stringArray;

}

void CIMValue::get(Array<CIMDateTime>& x) const

{

#ifdef CIMValueisNullexception

if (_rep->_type != CIMTYPE_DATETIME || !_rep->_isArray)

if (_isNull)

throw TypeMismatchException();

throw CIMValueIsNull();

#endif

if (_type != CIMType::DATETIME || !_isArray)

throw TypeMismatch();

x.set(_u._dateTimeArray);

if (!_rep->_isNull)

x = *_rep->_u._dateTimeArray;

}

void CIMValue::get(Array<CIMReference>& x) const

void CIMValue::get(Array<CIMObjectPath>& x) const

{

if (_type != CIMType::REFERENCE || !_isArray)

if (_rep->_type != CIMTYPE_REFERENCE || !_rep->_isArray)

throw TypeMismatch();

throw TypeMismatchException();

x.set(_u._referenceArray);

if (!_rep->_isNull)

x = *_rep->_u._referenceArray;

}

void CIMValue::_init()

void CIMValue::get(Array<CIMObject>& x) const

{

_type = CIMType::NONE;

if (_rep->_type != CIMTYPE_OBJECT || !_rep->_isArray)

_isArray = false;

throw TypeMismatchException();

_isNull = true;

_u._voidPtr = 0;

if (!_rep->_isNull)

x = *_rep->_u._objectArray;

}

Boolean operator==(const CIMValue& x, const CIMValue& y)

Boolean CIMValue::equal(const CIMValue& x) const

{

if (!x.typeCompatible(y))

if (!typeCompatible(x))

return false;

if (x._isNull != y._isNull)

if (_rep->_isNull != x._rep->_isNull)

return false;

if (x._isArray)

if (_rep->_isArray)

{

switch (x._type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

return Array<Boolean>(x._u._booleanArray) ==

return (*_rep->_u._booleanArray) ==

Array<Boolean>(y._u._booleanArray);

(*x._rep->_u._booleanArray);

case CIMTYPE_UINT8:

return (*_rep->_u._uint8Array) ==

(*x._rep->_u._uint8Array);

case CIMType::UINT8:

case CIMTYPE_SINT8:

return Array<Uint8>(x._u._uint8Array) ==

return (*_rep->_u._sint8Array) ==

Array<Uint8>(y._u._uint8Array);

(*x._rep->_u._sint8Array);

case CIMType::SINT8:

case CIMTYPE_UINT16:

return Array<Sint8>(x._u._sint8Array) ==

return (*_rep->_u._uint16Array) ==

Array<Sint8>(y._u._sint8Array);

(*x._rep->_u._uint16Array);

case CIMType::UINT16:

case CIMTYPE_SINT16:

return Array<Uint16>(x._u._uint16Array) ==

return (*_rep->_u._sint16Array) ==

Array<Uint16>(y._u._uint16Array);

(*x._rep->_u._sint16Array);

case CIMType::SINT16:

case CIMTYPE_UINT32:

return Array<Sint16>(x._u._sint16Array) ==

return (*_rep->_u._uint32Array) ==

Array<Sint16>(y._u._sint16Array);

(*x._rep->_u._uint32Array);

case CIMType::UINT32:

case CIMTYPE_SINT32:

return Array<Uint32>(x._u._uint32Array) ==

return (*_rep->_u._sint32Array) ==

Array<Uint32>(y._u._uint32Array);

(*x._rep->_u._sint32Array);

case CIMType::SINT32:

case CIMTYPE_UINT64:

return Array<Sint32>(x._u._sint32Array) ==

return (*_rep->_u._uint64Array) ==

Array<Sint32>(y._u._sint32Array);

(*x._rep->_u._uint64Array);

case CIMType::UINT64:

case CIMTYPE_SINT64:

return Array<Uint64>(x._u._uint64Array) ==

return (*_rep->_u._sint64Array) ==

Array<Uint64>(y._u._uint64Array);

(*x._rep->_u._sint64Array);

case CIMType::SINT64:

case CIMTYPE_REAL32:

return Array<Sint64>(x._u._sint64Array) ==

return (*_rep->_u._real32Array) ==

Array<Sint64>(y._u._sint64Array);

(*x._rep->_u._real32Array);

case CIMType::REAL32:

case CIMTYPE_REAL64:

return Array<Real32>(x._u._real32Array) ==

return (*_rep->_u._real64Array) ==

Array<Real32>(y._u._real32Array);

(*x._rep->_u._real64Array);

case CIMType::REAL64:

case CIMTYPE_CHAR16:

return Array<Real64>(x._u._real64Array) ==

return (*_rep->_u._char16Array) ==

Array<Real64>(y._u._real64Array);

(*x._rep->_u._char16Array);

case CIMType::CHAR16:

case CIMTYPE_STRING:

return Array<Char16>(x._u._char16Array) ==

return (*_rep->_u._stringArray) ==

Array<Char16>(y._u._char16Array);

(*x._rep->_u._stringArray);

case CIMType::STRING:

case CIMTYPE_DATETIME:

return Array<String>(x._u._stringArray) ==

return (*_rep->_u._dateTimeArray) ==

Array<String>(y._u._stringArray);

(*x._rep->_u._dateTimeArray);

case CIMType::DATETIME:

case CIMTYPE_REFERENCE:

return Array<CIMDateTime>(x._u._dateTimeArray) ==

return (*_rep->_u._referenceArray) ==

Array<CIMDateTime>(y._u._dateTimeArray);

(*x._rep->_u._referenceArray);

case CIMTYPE_OBJECT:

return (*_rep->_u._objectArray) ==

(*x._rep->_u._objectArray);

case CIMType::REFERENCE:

return Array<CIMReference>(x._u._referenceArray) ==

Array<CIMReference>(y._u._referenceArray);

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(false);

}

else

{

switch (x._type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

return x._u._booleanValue == y._u._booleanValue;

return _rep->_u._booleanValue == x._rep->_u._booleanValue;

case CIMTYPE_UINT8:

return _rep->_u._uint8Value == x._rep->_u._uint8Value;

case CIMTYPE_SINT8:

return _rep->_u._sint8Value == x._rep->_u._sint8Value;

case CIMType::UINT8:

case CIMTYPE_UINT16:

return x._u._uint8Value == y._u._uint8Value;

return _rep->_u._uint16Value == x._rep->_u._uint16Value;

case CIMType::SINT8:

case CIMTYPE_SINT16:

return x._u._sint8Value == y._u._sint8Value;

return _rep->_u._sint16Value == x._rep->_u._sint16Value;

case CIMType::UINT16:

case CIMTYPE_UINT32:

return x._u._uint16Value == y._u._uint16Value;

return _rep->_u._uint32Value == x._rep->_u._uint32Value;

case CIMType::SINT16:

case CIMTYPE_SINT32:

return x._u._sint16Value == y._u._sint16Value;

return _rep->_u._sint32Value == x._rep->_u._sint32Value;

case CIMType::UINT32:

case CIMTYPE_UINT64:

return x._u._uint32Value == y._u._uint32Value;

return _rep->_u._uint64Value == x._rep->_u._uint64Value;

case CIMType::SINT32:

case CIMTYPE_SINT64:

return x._u._sint32Value == y._u._sint32Value;

return _rep->_u._sint64Value == x._rep->_u._sint64Value;

case CIMType::UINT64:

case CIMTYPE_REAL32:

return x._u._uint64Value == y._u._uint64Value;

return _rep->_u._real32Value == x._rep->_u._real32Value;

case CIMType::SINT64:

case CIMTYPE_REAL64:

return x._u._sint64Value == y._u._sint64Value;

return _rep->_u._real64Value == x._rep->_u._real64Value;

case CIMType::REAL32:

case CIMTYPE_CHAR16:

return x._u._real32Value == y._u._real32Value;

return _rep->_u._char16Value == x._rep->_u._char16Value;

case CIMType::REAL64:

case CIMTYPE_STRING:

return x._u._real64Value == y._u._real64Value;

return String::equal(*_rep->_u._stringValue,

*x._rep->_u._stringValue);

case CIMType::CHAR16:

case CIMTYPE_DATETIME:

return x._u._char16Value == y._u._char16Value;

return *_rep->_u._dateTimeValue == *x._rep->_u._dateTimeValue;

case CIMType::STRING:

case CIMTYPE_REFERENCE:

return String::equal(*x._u._stringValue, *y._u._stringValue);

return *_rep->_u._referenceValue ==

*x._rep->_u._referenceValue;

case CIMType::DATETIME:

case CIMTYPE_OBJECT:

return *x._u._dateTimeValue == *y._u._dateTimeValue;

return (*_rep->_u._objectValue).identical((*x._rep->_u._objectValue));

case CIMType::REFERENCE:

return *x._u._referenceValue == *y._u._referenceValue;

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(false);

}

// Unreachable!

return false;

PEGASUS_UNREACHABLE( return false; )

}

void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize)

String CIMValue::toString() const

{

Buffer out;

clear();

//ATTN: Not sure what we should do with getstring for Null CIMValues

//Choice return empty string or exception out.

if (_rep->_isNull)

return String();

if (isArray)

if (_rep->_isArray)

{

switch (type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

set(Array<Boolean>(arraySize));

{

Uint32 size = _rep->_u._booleanArray->size();

for (Uint32 i = 0; i < size; i++)

{

_toString(out, Boolean(_rep->_u._booleanArray->getData()[i]));

out << " ";

}

break;

}

case CIMType::UINT8:

case CIMTYPE_UINT8:

set(Array<Uint8>(arraySize));

_toString(out, _rep->_u._uint8Array->getData(),

_rep->_u._uint8Array->size());

break;

case CIMType::SINT8:

case CIMTYPE_SINT8:

set(Array<Sint8>(arraySize));

_toString(out, _rep->_u._sint8Array->getData(),

_rep->_u._sint8Array->size());

break;

case CIMType::UINT16:

case CIMTYPE_UINT16:

set(Array<Uint16>(arraySize));

_toString(out, _rep->_u._uint16Array->getData(),

_rep->_u._uint16Array->size());

break;

case CIMType::SINT16:

case CIMTYPE_SINT16:

set(Array<Sint16>(arraySize));

_toString(out, _rep->_u._sint16Array->getData(),

_rep->_u._sint16Array->size());

break;

case CIMType::UINT32:

case CIMTYPE_UINT32:

set(Array<Uint32>(arraySize));

_toString(out, _rep->_u._uint32Array->getData(),

_rep->_u._uint32Array->size());

break;

case CIMType::SINT32:

case CIMTYPE_SINT32:

set(Array<Sint32>(arraySize));

_toString(out, _rep->_u._sint32Array->getData(),

_rep->_u._sint32Array->size());

break;

case CIMType::UINT64:

case CIMTYPE_UINT64:

set(Array<Uint64>(arraySize));

_toString(out, _rep->_u._uint64Array->getData(),

_rep->_u._uint64Array->size());

break;

case CIMType::SINT64:

case CIMTYPE_SINT64:

set(Array<Sint64>(arraySize));

_toString(out, _rep->_u._sint64Array->getData(),

_rep->_u._sint64Array->size());

break;

case CIMType::REAL32:

case CIMTYPE_REAL32:

set(Array<Real32>(arraySize));

_toString(out, _rep->_u._real32Array->getData(),

_rep->_u._real32Array->size());

break;

case CIMType::REAL64:

case CIMTYPE_REAL64:

set(Array<Real64>(arraySize));

_toString(out, _rep->_u._real64Array->getData(),

_rep->_u._real64Array->size());

break;

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

set(Array<Char16>(arraySize));

_toString(out, _rep->_u._char16Array->getData(),

_rep->_u._char16Array->size());

break;

case CIMType::STRING:

case CIMTYPE_STRING:

set(Array<String>(arraySize));

_toString(out, _rep->_u._stringArray->getData(),

_rep->_u._stringArray->size());

break;

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

set(Array<CIMDateTime>(arraySize));

_toString(out, _rep->_u._dateTimeArray->getData(),

_rep->_u._dateTimeArray->size());

break;

case CIMType::REFERENCE:

case CIMTYPE_REFERENCE:

set(Array<CIMReference>(arraySize));

_toString(out, _rep->_u._referenceArray->getData(),

_rep->_u._referenceArray->size());

break;

case CIMTYPE_OBJECT:

_toString(out, _rep->_u._objectArray->getData(),

_rep->_u._objectArray->size());

break;

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(false);

}

else

{

switch (type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

set(false);

_toString(out, Boolean(_rep->_u._booleanValue != 0));

break;

case CIMType::UINT8:

case CIMTYPE_UINT8:

set(Uint8(0));

_toString(out, _rep->_u._uint8Value);

break;

case CIMType::SINT8:

case CIMTYPE_SINT8:

set(Sint8(0));

_toString(out, _rep->_u._sint8Value);

break;

case CIMType::UINT16:

case CIMTYPE_UINT16:

set(Uint16(0));

_toString(out, _rep->_u._uint16Value);

break;

case CIMType::SINT16:

case CIMTYPE_SINT16:

set(Sint16(0));

_toString(out, _rep->_u._sint16Value);

break;

case CIMType::UINT32:

case CIMTYPE_UINT32:

set(Uint32(0));

_toString(out, _rep->_u._uint32Value);

break;

case CIMType::SINT32:

case CIMTYPE_SINT32:

set(Sint32(0));

_toString(out, _rep->_u._sint32Value);

break;

case CIMType::UINT64:

case CIMTYPE_UINT64:

set(Uint64(0));

_toString(out, _rep->_u._uint64Value);

break;

case CIMType::SINT64:

case CIMTYPE_SINT64:

set(Sint64(0));

_toString(out, _rep->_u._sint64Value);

break;

case CIMType::REAL32:

case CIMTYPE_REAL32:

set(Real32(0.0));

_toString(out, _rep->_u._real32Value);

break;

case CIMType::REAL64:

case CIMTYPE_REAL64:

set(Real64(0.0));

_toString(out, _rep->_u._real64Value);

break;

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

set(Char16(0));

_toString(out, Char16(_rep->_u._char16Value));

break;

case CIMType::STRING:

case CIMTYPE_STRING:

set(String());

_toString(out, *_rep->_u._stringValue);

break;

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

set(CIMDateTime());

_toString(out, *_rep->_u._dateTimeValue);

break;

case CIMType::REFERENCE:

case CIMTYPE_REFERENCE:

set(CIMReference());

_toString(out, *_rep->_u._referenceValue);

break;

case CIMTYPE_OBJECT:

_toString(out, *_rep->_u._objectValue);

break;

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(false);

}

// Set the Null attribute. Note that this must be after the set

out.append('\0');

// because the set functions sets the _isNull.

return out.getData();

_isNull = true;

}

String CIMValue::toString() const

{

Array<Sint8> out;

//ATTN: Not sure what we should do with getstring for Null CIMValues

//Choice return empty string or exception out.

if (_isNull)

return String();

if (_isArray)

Boolean operator==(const CIMValue& x, const CIMValue& y)

{

switch (_type)

{

case CIMType::BOOLEAN:

{

int size = _u._booleanArray->size;

bool *p = _u._booleanArray->data();

for (Uint32 i = 0; i < _u._booleanArray->size; i++)

{

_toString(out, Boolean(_u._booleanArray->data()[i]));

return x.equal(y);

out << " ";

}

break;

}

case CIMType::UINT8:

Boolean operator!=(const CIMValue& x, const CIMValue& y)

_toString(out, _u._uint8Array->data(), _u._uint8Array->size);

break;

case CIMType::SINT8:

_toString(out, _u._sint8Array->data(), _u._sint8Array->size);

break;

case CIMType::UINT16:

_toString(out, _u._uint16Array->data(), _u._uint16Array->size);

break;

case CIMType::SINT16:

_toString(out, _u._sint16Array->data(), _u._sint16Array->size);

break;

case CIMType::UINT32:

_toString(out, _u._uint32Array->data(), _u._uint32Array->size);

break;

case CIMType::SINT32:

_toString(out, _u._sint32Array->data(), _u._sint32Array->size);

break;

case CIMType::UINT64:

_toString(out, _u._uint64Array->data(), _u._uint64Array->size);

break;

case CIMType::SINT64:

_toString(out, _u._sint64Array->data(), _u._sint64Array->size);

break;

case CIMType::REAL32:

_toString(out, _u._real32Array->data(), _u._real32Array->size);

break;

case CIMType::REAL64:

_toString(out, _u._real64Array->data(), _u._real64Array->size);

break;

case CIMType::CHAR16:

_toString(out, _u._char16Array->data(), _u._char16Array->size);

break;

case CIMType::STRING:

_toString(out, _u._stringArray->data(), _u._stringArray->size);

break;

case CIMType::DATETIME:

_toString(out, _u._dateTimeArray->data(), _u._dateTimeArray->size);

break;

case CIMType::REFERENCE:

_toString(out, _u._referenceArray->data(), _u._referenceArray->size);

break;

default:

throw CIMValueInvalidType();

}

else

{

switch (_type)

return !x.equal(y);

{

}

case CIMType::BOOLEAN:

_toString(out, Boolean(_u._booleanValue != 0));

break;

case CIMType::UINT8:

_toString(out, _u._uint8Value);

break;

case CIMType::SINT8:

_toString(out, _u._sint8Value);

break;

case CIMType::UINT16:

_toString(out, _u._uint16Value);

break;

case CIMType::SINT16:

_toString(out, _u._sint16Value);

break;

case CIMType::UINT32:

_toString(out, _u._uint32Value);

break;

case CIMType::SINT32:

_toString(out, _u._sint32Value);

break;

case CIMType::UINT64:

_toString(out, _u._uint64Value);

break;

case CIMType::SINT64:

_toString(out, _u._sint64Value);

break;

case CIMType::REAL32:

_toString(out, _u._real32Value);

break;

case CIMType::REAL64:

#ifdef PEGASUS_USE_DEPRECATED_INTERFACES

_toString(out, _u._real64Value);

break;

case CIMType::CHAR16:

CIMValue::CIMValue(char x)

_toString(out, Char16(_u._char16Value));

{

break;

_rep = new CIMValueRep();

set(x);

case CIMType::STRING:

}

_toString(out, *_u._stringValue);

break;

case CIMType::DATETIME:

CIMValue::CIMValue(const Array<char>& x)

_toString(out, *_u._dateTimeValue);

{

break;

_rep = new CIMValueRep();

set(x);

}

case CIMType::REFERENCE:

void CIMValue::set(char x)

_toString(out, *_u._referenceValue);

{

break;

set(static_cast<Sint8>(x));

}

default:

void CIMValue::set(const Array<char>& x)

throw CIMValueInvalidType();

{

set(*reinterpret_cast<const Array<Sint8> *>(&x));

}

void CIMValue::get(char& x) const

{

get(*reinterpret_cast<Sint8 *>(&x));

}

out.append('\0');

void CIMValue::get(Array<char>& x) const

return out.getData();

{

get(*reinterpret_cast<Array<Sint8> *>(&x));

}

#endif

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.24
changed lines
	Added in v.1.59.2.1

No CVS admin address has been configured