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.28 and 1.37

version 1.28, 2002/05/14 05:10:33

version 1.37, 2002/08/16 01:28:06

Line 1

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

// The Open Group, Tivoli Systems

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

// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

// Karl Schopmeyer, (k.schopmeyer@opengroup.org)

// Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

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

#include <cstring>

#include <cstdio>

#include <cassert>

#include <cctype>

#include "CIMValue.h"

#include "Union.h"

Line 42

Line 44

# 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:

// _toString routines:

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

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

#if 0

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

// _SignedIntToStr()

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

static void _SignedIntToStr(Sint64 x, char* result)

{

if (!result)

return;

if (x == 0)

{

result[0] = '0';

result[1] = '\0';

return;

}

char buffer[32];

Uint32 len = 0;

Boolean negative = false;

while (x)

{

Sint32 r = x % 10;

x = x / 10;

if (r < 0)

{

r = -r;

negative = true;

}

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

}

buffer[len] = '\0';

// If buffer was negative, prepend sign:

char* q = result;

if (negative)

*q++ = '-';

// Reverse the buffer:

char* p = &buffer[len];

while (len--)

*q++ = *--p;

*q++ = '\0';

}

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

// _UnsignedIntToStr()

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

static void _UnsignedIntToStr(Uint64 x, char* result)

{

if (!result)

return;

if (x == 0)

{

result[0] = '0';

result[1] = '\0';

return;

}

char buffer[32];

Uint32 len = 0;

while (x)

{

Uint32 r = x % 10;

x = x / 10;

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

}

buffer[len] = '\0';

// Reverse the buffer onto output:

char* q = result;

char* p = &buffer[len];

while (len--)

*q++ = *--p;

*q++ = '\0';

}

#endif

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

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

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

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

{

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

XmlWriter::append(out, x);

}

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

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

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

{

char buffer[32];

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

out << (char*)buffer;

}

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

inline void _toString(Array<Sint8>& out, Uint8 x) { XmlWriter::append(out, Uint32(x)); }

{

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

char buffer[32];

inline void _toString(Array<Sint8>& out, Uint16 x) { XmlWriter::append(out, Uint32(x)); }

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

inline void _toString(Array<Sint8>& out, Sint16 x) { XmlWriter::append(out, Sint32(x)); }

out << (char*)buffer;

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, Uint8 x) { _unsignedIntegerToString(out, x); }

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

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

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

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

inline void _toString(Array<Sint8>& out, Real64 x) { XmlWriter::append(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

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

#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)

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

#else

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

#endif

out << buffer;

}

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

inline void _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

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

#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)

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

#else

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

#endif

out << buffer;

}

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

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

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

{

char buffer[128];

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

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

out << buffer;

}

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

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

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

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

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

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

{

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

out.append(Sint8(x));

}

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

{

XmlWriter::appendSpecial(out, x);

}

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

{

XmlWriter::appendSpecial(out, x);

}

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

{

out << x;

}

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

{

XmlWriter::appendSpecial(out, x);

}

/** _toMof Internal function to convert the string back

to MOF format and output it.

The conversions are:

\b // \x0008: backspace BS

\t // \x0009: horizontal tab HT

\n // \x000A: linefeed LF

\f // \x000C: form feed FF

\r // \x000D: carriage return CR

\" // \x0022: double quote "

\� // \x0027: single quote '

\\ // \x005C: backslash \

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

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

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

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

{

out << "\"";

const Char16* tmp = x.getData();

char c;

while ((c = *tmp++))

{

switch (c)

{

case '\\':

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

break;

case '\b':

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

break;

case '\t':

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

break;

case '\n':

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

break;

case '\f':

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

break;

case '\r':

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

break;

/* case '\'':

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

break;*/

case '"':

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

break;

default:

out.append(Sint8(c));

}

out << "\"";

}

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

{

out << x.getString();

}

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

inline void _toString(Array<Sint8>& out, const CIMObjectPath& 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();

}

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

{

x.toXml(out);

}

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

{

x.toMof(out);

}

template<class T>

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

Line 378

Line 97

}

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

{

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

while (size--)

{

_toXml(out, *p++);

}

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

}

template<class T>

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

{

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

while (size--)

{

out << "<VALUE>";

_toXml(out, *p++);

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

}

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

}

/** _toMof Array -

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

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 << "{";

while (size--)

{

// Put comma on all but first entry.

if (!isFirstEntry)

{

out << ", ";

}

isFirstEntry = false;

_toMof(out, *p++);

}

out << "}";

}

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

Line 451

Line 118

void reset()

{

_type = CIMType::NONE;

_type = CIMTYPE_NONE;

_isArray = false;

_isNull = true;

_u._voidPtr = 0;

Line 559

Line 226

set(x);

}

CIMValue::CIMValue(const char* x)

{

_rep = new CIMValueRep();

set(x);

}

CIMValue::CIMValue(const CIMDateTime& x)

{

_rep = new CIMValueRep();

set(x);

}

CIMValue::CIMValue(const CIMReference& x)

CIMValue::CIMValue(const CIMObjectPath& x)

{

_rep = new CIMValueRep();

set(x);

Line 661

Line 322

set(x);

}

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

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

{

_rep = new CIMValueRep();

set(x);

Line 701

Line 362

{

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

_Inc(_rep->_u._booleanArray = x._rep->_u._booleanArray);

_rep->_u._booleanArray =

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

break;

case CIMType::UINT8:

case CIMTYPE_UINT8:

_Inc(_rep->_u._uint8Array = x._rep->_u._uint8Array);

_rep->_u._uint8Array =

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

break;

case CIMType::SINT8:

case CIMTYPE_SINT8:

_Inc(_rep->_u._sint8Array = x._rep->_u._sint8Array);

_rep->_u._sint8Array =

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

break;

case CIMType::UINT16:

case CIMTYPE_UINT16:

_Inc(_rep->_u._uint16Array = x._rep->_u._uint16Array);

_rep->_u._uint16Array =

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

break;

case CIMType::SINT16:

case CIMTYPE_SINT16:

_Inc(_rep->_u._sint16Array = x._rep->_u._sint16Array);

_rep->_u._sint16Array =

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

break;

case CIMType::UINT32:

case CIMTYPE_UINT32:

_Inc(_rep->_u._uint32Array = x._rep->_u._uint32Array);

_rep->_u._uint32Array =

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

break;

case CIMType::SINT32:

case CIMTYPE_SINT32:

_Inc(_rep->_u._sint32Array = x._rep->_u._sint32Array);

_rep->_u._sint32Array =

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

break;

case CIMType::UINT64:

case CIMTYPE_UINT64:

_Inc(_rep->_u._uint64Array = x._rep->_u._uint64Array);

_rep->_u._uint64Array =

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

break;

case CIMType::SINT64:

case CIMTYPE_SINT64:

_Inc(_rep->_u._sint64Array = x._rep->_u._sint64Array);

_rep->_u._sint64Array =

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

break;

case CIMType::REAL32:

case CIMTYPE_REAL32:

_Inc(_rep->_u._real32Array = x._rep->_u._real32Array);

_rep->_u._real32Array =

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

break;

case CIMType::REAL64:

case CIMTYPE_REAL64:

_Inc(_rep->_u._real64Array = x._rep->_u._real64Array);

_rep->_u._real64Array =

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

break;

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

_Inc(_rep->_u._char16Array = x._rep->_u._char16Array);

_rep->_u._char16Array =

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

break;

case CIMType::STRING:

case CIMTYPE_STRING:

_Inc(_rep->_u._stringArray = x._rep->_u._stringArray);

_rep->_u._stringArray =

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

break;

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

_Inc(_rep->_u._dateTimeArray = x._rep->_u._dateTimeArray);

_rep->_u._dateTimeArray =

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

break;

case CIMType::REFERENCE:

case CIMTYPE_REFERENCE:

_Inc(_rep->_u._referenceArray = x._rep->_u._referenceArray);

_rep->_u._referenceArray =

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

break;

default:

throw CIMValueInvalidType();

Line 768

Line 444

{

switch (_rep->_type)

{

case CIMType::NONE:

case CIMTYPE_NONE:

break;

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;

case CIMType::STRING:

case CIMTYPE_STRING:

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

break;

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

_rep->_u._dateTimeValue =

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

break;

case CIMType::REFERENCE:

case CIMTYPE_REFERENCE:

_rep->_u._referenceValue =

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

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

break;

// Should never get here. testing complete enum

Line 849

Line 525

{

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

_Dec(_rep->_u._booleanArray);

delete _rep->_u._booleanArray;

break;

case CIMType::UINT8:

case CIMTYPE_UINT8:

_Dec(_rep->_u._uint8Array);

delete _rep->_u._uint8Array;

break;

case CIMType::SINT8:

case CIMTYPE_SINT8:

_Dec(_rep->_u._sint8Array);

delete _rep->_u._sint8Array;

break;

case CIMType::UINT16:

case CIMTYPE_UINT16:

_Dec(_rep->_u._uint16Array);

delete _rep->_u._uint16Array;

break;

case CIMType::SINT16:

case CIMTYPE_SINT16:

_Dec(_rep->_u._sint16Array);

delete _rep->_u._sint16Array;

break;

case CIMType::UINT32:

case CIMTYPE_UINT32:

_Dec(_rep->_u._uint32Array);

delete _rep->_u._uint32Array;

break;

case CIMType::SINT32:

case CIMTYPE_SINT32:

_Dec(_rep->_u._sint32Array);

delete _rep->_u._sint32Array;

break;

case CIMType::UINT64:

case CIMTYPE_UINT64:

_Dec(_rep->_u._uint64Array);

delete _rep->_u._uint64Array;

break;

case CIMType::SINT64:

case CIMTYPE_SINT64:

_Dec(_rep->_u._sint64Array);

delete _rep->_u._sint64Array;

break;

case CIMType::REAL32:

case CIMTYPE_REAL32:

_Dec(_rep->_u._real32Array);

delete _rep->_u._real32Array;

break;

case CIMType::REAL64:

case CIMTYPE_REAL64:

_Dec(_rep->_u._real64Array);

delete _rep->_u._real64Array;

break;

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

_Dec(_rep->_u._char16Array);

delete _rep->_u._char16Array;

break;

case CIMType::STRING:

case CIMTYPE_STRING:

_Dec(_rep->_u._stringArray);

delete _rep->_u._stringArray;

break;

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

_Dec(_rep->_u._dateTimeArray);

delete _rep->_u._dateTimeArray;

break;

case CIMType::REFERENCE:

case CIMTYPE_REFERENCE:

_Dec(_rep->_u._referenceArray);

delete _rep->_u._referenceArray;

break;

//default:

Line 917

Line 593

{

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

case CIMType::UINT8:

case CIMTYPE_UINT8:

case CIMType::SINT8:

case CIMTYPE_SINT8:

case CIMType::UINT16:

case CIMTYPE_UINT16:

case CIMType::SINT16:

case CIMTYPE_SINT16:

case CIMType::UINT32:

case CIMTYPE_UINT32:

case CIMType::SINT32:

case CIMTYPE_SINT32:

case CIMType::UINT64:

case CIMTYPE_UINT64:

case CIMType::SINT64:

case CIMTYPE_SINT64:

case CIMType::REAL32:

case CIMTYPE_REAL32:

case CIMType::REAL64:

case CIMTYPE_REAL64:

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

break;

case CIMType::STRING:

case CIMTYPE_STRING:

delete _rep->_u._stringValue;

break;

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

delete _rep->_u._dateTimeValue;

break;

case CIMType::REFERENCE:

case CIMTYPE_REFERENCE:

delete _rep->_u._referenceValue;

break;

//default:

Line 952

Line 628

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

{

return _rep->_type == x._rep->_type && _rep->_isArray == x._rep->_isArray;

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

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

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

}

Boolean CIMValue::isArray() const

Line 972

Line 650

switch (_rep->_type)

{

case CIMType::NONE:

case CIMTYPE_NONE:

return 0;

break;

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

return _rep->_u._booleanArray->size;

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

break;

case CIMType::UINT8:

case CIMTYPE_UINT8:

return _rep->_u._uint8Array->size;

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

break;

case CIMType::SINT8:

case CIMTYPE_SINT8:

return _rep->_u._sint8Array->size;

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

break;

case CIMType::UINT16:

case CIMTYPE_UINT16:

return _rep->_u._uint16Array->size;

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

break;

case CIMType::SINT16:

case CIMTYPE_SINT16:

return _rep->_u._sint16Array->size;

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

break;

case CIMType::UINT32:

case CIMTYPE_UINT32:

return _rep->_u._uint32Array->size;

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

break;

case CIMType::SINT32:

case CIMTYPE_SINT32:

return _rep->_u._sint32Array->size;

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

break;

case CIMType::UINT64:

case CIMTYPE_UINT64:

return _rep->_u._uint64Array->size;

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

break;

case CIMType::SINT64:

case CIMTYPE_SINT64:

return _rep->_u._sint64Array->size;

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

break;

case CIMType::REAL32:

case CIMTYPE_REAL32:

return _rep->_u._real32Array->size;

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

break;

case CIMType::REAL64:

case CIMTYPE_REAL64:

return _rep->_u._real64Array->size;

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

break;

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

return _rep->_u._char16Array->size;

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

break;

case CIMType::STRING:

case CIMTYPE_STRING:

return _rep->_u._stringArray->size;

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

break;

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

return _rep->_u._dateTimeArray->size;

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

break;

case CIMType::REFERENCE:

case CIMTYPE_REFERENCE:

return _rep->_u._referenceArray->size;

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

break;

// Should never get here. switch on complete enum

default:

Line 1059

Line 737

{

switch (type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

set(Array<Boolean>(arraySize));

break;

case CIMType::UINT8:

case CIMTYPE_UINT8:

set(Array<Uint8>(arraySize));

break;

case CIMType::SINT8:

case CIMTYPE_SINT8:

set(Array<Sint8>(arraySize));

break;

case CIMType::UINT16:

case CIMTYPE_UINT16:

set(Array<Uint16>(arraySize));

break;

case CIMType::SINT16:

case CIMTYPE_SINT16:

set(Array<Sint16>(arraySize));

break;

case CIMType::UINT32:

case CIMTYPE_UINT32:

set(Array<Uint32>(arraySize));

break;

case CIMType::SINT32:

case CIMTYPE_SINT32:

set(Array<Sint32>(arraySize));

break;

case CIMType::UINT64:

case CIMTYPE_UINT64:

set(Array<Uint64>(arraySize));

break;

case CIMType::SINT64:

case CIMTYPE_SINT64:

set(Array<Sint64>(arraySize));

break;

case CIMType::REAL32:

case CIMTYPE_REAL32:

set(Array<Real32>(arraySize));

break;

case CIMType::REAL64:

case CIMTYPE_REAL64:

set(Array<Real64>(arraySize));

break;

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

set(Array<Char16>(arraySize));

break;

case CIMType::STRING:

case CIMTYPE_STRING:

set(Array<String>(arraySize));

break;

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

set(Array<CIMDateTime>(arraySize));

break;

case CIMType::REFERENCE:

case CIMTYPE_REFERENCE:

set(Array<CIMReference>(arraySize));

set(Array<CIMObjectPath>(arraySize));

break;

default:

throw CIMValueInvalidType();

Line 1126

Line 804

{

switch (type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

set(false);

break;

case CIMType::UINT8:

case CIMTYPE_UINT8:

set(Uint8(0));

break;

case CIMType::SINT8:

case CIMTYPE_SINT8:

set(Sint8(0));

break;

case CIMType::UINT16:

case CIMTYPE_UINT16:

set(Uint16(0));

break;

case CIMType::SINT16:

case CIMTYPE_SINT16:

set(Sint16(0));

break;

case CIMType::UINT32:

case CIMTYPE_UINT32:

set(Uint32(0));

break;

case CIMType::SINT32:

case CIMTYPE_SINT32:

set(Sint32(0));

break;

case CIMType::UINT64:

case CIMTYPE_UINT64:

set(Uint64(0));

break;

case CIMType::SINT64:

case CIMTYPE_SINT64:

set(Sint64(0));

break;

case CIMType::REAL32:

case CIMTYPE_REAL32:

set(Real32(0.0));

break;

case CIMType::REAL64:

case CIMTYPE_REAL64:

set(Real64(0.0));

break;

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

set(Char16(0));

break;

case CIMType::STRING:

case CIMTYPE_STRING:

set(String());

break;

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

set(CIMDateTime());

break;

case CIMType::REFERENCE:

case CIMTYPE_REFERENCE:

set(CIMReference());

set(CIMObjectPath());

break;

default:

throw CIMValueInvalidType();

Line 1200

Line 878

{

clear();

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

_rep->_type = CIMType::BOOLEAN;

_rep->_type = CIMTYPE_BOOLEAN;

_rep->_isNull = false;

}

Line 1208

Line 886

{

clear();

_rep->_u._uint8Value = x;

_rep->_type = CIMType::UINT8;

_rep->_type = CIMTYPE_UINT8;

_rep->_isNull = false;

}

Line 1216

Line 894

{

clear();

_rep->_u._sint8Value = x;

_rep->_type = CIMType::SINT8;

_rep->_type = CIMTYPE_SINT8;

_rep->_isNull = false;

}

Line 1224

Line 902

{

clear();

_rep->_u._uint16Value = x;

_rep->_type = CIMType::UINT16;

_rep->_type = CIMTYPE_UINT16;

_rep->_isNull = false;

}

Line 1232

Line 910

{

clear();

_rep->_u._sint16Value = x;

_rep->_type = CIMType::SINT16;

_rep->_type = CIMTYPE_SINT16;

_rep->_isNull = false;

}

Line 1240

Line 918

{

clear();

_rep->_u._uint32Value = x;

_rep->_type = CIMType::UINT32;

_rep->_type = CIMTYPE_UINT32;

_rep->_isNull = false;

}

Line 1248

Line 926

{

clear();

_rep->_u._sint32Value = x;

_rep->_type = CIMType::SINT32;

_rep->_type = CIMTYPE_SINT32;

_rep->_isNull = false;

}

Line 1256

Line 934

{

clear();

_rep->_u._uint64Value = x;

_rep->_type = CIMType::UINT64;

_rep->_type = CIMTYPE_UINT64;

_rep->_isNull = false;

}

Line 1264

Line 942

{

clear();

_rep->_u._sint64Value = x;

_rep->_type = CIMType::SINT64;

_rep->_type = CIMTYPE_SINT64;

_rep->_isNull = false;

}

Line 1272

Line 950

{

clear();

_rep->_u._real32Value = x;

_rep->_type = CIMType::REAL32;

_rep->_type = CIMTYPE_REAL32;

_rep->_isNull = false;

}

Line 1280

Line 958

{

clear();

_rep->_u._real64Value = x;

_rep->_type = CIMType::REAL64;

_rep->_type = CIMTYPE_REAL64;

_rep->_isNull = false;

}

Line 1288

Line 966

{

clear();

_rep->_u._char16Value = x;

_rep->_type = CIMType::CHAR16;

_rep->_type = CIMTYPE_CHAR16;

_rep->_isNull = false;

}

Line 1296

Line 974

{

clear();

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

_rep->_type = CIMType::STRING;

_rep->_type = CIMTYPE_STRING;

_rep->_isNull = false;

}

void CIMValue::set(const char* x)

{

set(String(x));

_rep->_isNull = false;

}

Line 1310

Line 982

{

clear();

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

_rep->_type = CIMType::DATETIME;

_rep->_type = CIMTYPE_DATETIME;

_rep->_isNull = false;

}

void CIMValue::set(const CIMReference& x)

void CIMValue::set(const CIMObjectPath& x)

{

clear();

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

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

_rep->_type = CIMType::REFERENCE;

_rep->_type = CIMTYPE_REFERENCE;

_rep->_isNull = false;

}

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

{

clear();

_Inc(_rep->_u._booleanArray = x._rep);

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

_rep->_type = CIMType::BOOLEAN;

_rep->_type = CIMTYPE_BOOLEAN;

_rep->_isArray = true;

_rep->_isNull = false;

}

Line 1334

Line 1006

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

{

clear();

_Inc(_rep->_u._uint8Array = x._rep);

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

_rep->_type = CIMType::UINT8;

_rep->_type = CIMTYPE_UINT8;

_rep->_isArray = true;

_rep->_isNull = false;

}

Line 1343

Line 1015

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

{

clear();

_Inc(_rep->_u._sint8Array = x._rep);

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

_rep->_type = CIMType::SINT8;

_rep->_type = CIMTYPE_SINT8;

_rep->_isArray = true;

_rep->_isNull = false;

}

Line 1352

Line 1024

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

{

clear();

_Inc(_rep->_u._uint16Array = x._rep);

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

_rep->_type = CIMType::UINT16;

_rep->_type = CIMTYPE_UINT16;

_rep->_isArray = true;

_rep->_isNull = false;

}

Line 1361

Line 1033

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

{

clear();

_Inc(_rep->_u._sint16Array = x._rep);

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

_rep->_type = CIMType::SINT16;

_rep->_type = CIMTYPE_SINT16;

_rep->_isArray = true;

_rep->_isNull = false;

}

Line 1370

Line 1042

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

{

clear();

_Inc(_rep->_u._uint32Array = x._rep);

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

_rep->_type = CIMType::UINT32;

_rep->_type = CIMTYPE_UINT32;

_rep->_isArray = true;

_rep->_isNull = false;

}

Line 1379

Line 1051

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

{

clear();

_Inc(_rep->_u._sint32Array = x._rep);

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

_rep->_type = CIMType::SINT32;

_rep->_type = CIMTYPE_SINT32;

_rep->_isArray = true;

_rep->_isNull = false;

}

Line 1388

Line 1060

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

{

clear();

_Inc(_rep->_u._uint64Array = x._rep);

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

_rep->_type = CIMType::UINT64;

_rep->_type = CIMTYPE_UINT64;

_rep->_isArray = true;

_rep->_isNull = false;

}

Line 1397

Line 1069

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

{

clear();

_Inc(_rep->_u._sint64Array = x._rep);

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

_rep->_type = CIMType::SINT64;

_rep->_type = CIMTYPE_SINT64;

_rep->_isArray = true;

_rep->_isNull = false;

}

Line 1406

Line 1078

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

{

clear();

_Inc(_rep->_u._real32Array = x._rep);

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

_rep->_type = CIMType::REAL32;

_rep->_type = CIMTYPE_REAL32;

_rep->_isArray = true;

_rep->_isNull = false;

}

Line 1415

Line 1087

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

{

clear();

_Inc(_rep->_u._real64Array = x._rep);

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

_rep->_type = CIMType::REAL64;

_rep->_type = CIMTYPE_REAL64;

_rep->_isArray = true;

_rep->_isNull = false;

}

Line 1424

Line 1096

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

{

clear();

_Inc(_rep->_u._char16Array = x._rep);

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

_rep->_type = CIMType::CHAR16;

_rep->_type = CIMTYPE_CHAR16;

_rep->_isArray = true;

_rep->_isNull = false;

}

Line 1433

Line 1105

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

{

clear();

_Inc(_rep->_u._stringArray = x._rep);

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

_rep->_type = CIMType::STRING;

_rep->_type = CIMTYPE_STRING;

_rep->_isArray = true;

_rep->_isNull = false;

}

Line 1442

Line 1114

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

{

clear();

_Inc(_rep->_u._dateTimeArray = x._rep);

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

_rep->_type = CIMType::DATETIME;

_rep->_type = CIMTYPE_DATETIME;

_rep->_isArray = true;

_rep->_isNull = false;

}

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

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

{

clear();

_Inc(_rep->_u._referenceArray = x._rep);

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

_rep->_type = CIMType::REFERENCE;

_rep->_type = CIMTYPE_REFERENCE;

_rep->_isArray = true;

_rep->_isNull = false;

}

void CIMValue::get(Boolean& x) const

{

if (_rep->_type != CIMType::BOOLEAN || _rep->_isArray)

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

throw TypeMismatch();

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

Line 1467

Line 1139

void CIMValue::get(Uint8& x) const

{

if (_rep->_type != CIMType::UINT8 || _rep->_isArray)

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

throw TypeMismatch();

x = _rep->_u._uint8Value;

Line 1475

Line 1147

void CIMValue::get(Sint8& x) const

{

if (_rep->_type != CIMType::SINT8 || _rep->_isArray)

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

throw TypeMismatch();

x = _rep->_u._sint8Value;

Line 1483

Line 1155

void CIMValue::get(Uint16& x) const

{

if (_rep->_type != CIMType::UINT16 || _rep->_isArray)

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

throw TypeMismatch();

x = _rep->_u._uint16Value;

Line 1491

Line 1163

void CIMValue::get(Sint16& x) const

{

if (_rep->_type != CIMType::SINT16 || _rep->_isArray)

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

throw TypeMismatch();

x = _rep->_u._sint16Value;

Line 1499

Line 1171

void CIMValue::get(Uint32& x) const

{

if (_rep->_type != CIMType::UINT32 || _rep->_isArray)

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

throw TypeMismatch();

x = _rep->_u._uint32Value;

Line 1507

Line 1179

void CIMValue::get(Sint32& x) const

{

if (_rep->_type != CIMType::SINT32 || _rep->_isArray)

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

throw TypeMismatch();

x = _rep->_u._sint32Value;

Line 1515

Line 1187

void CIMValue::get(Uint64& x) const

{

if (_rep->_type != CIMType::UINT64 || _rep->_isArray)

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

throw TypeMismatch();

x = _rep->_u._uint64Value;

Line 1523

Line 1195

void CIMValue::get(Sint64& x) const

{

if (_rep->_type != CIMType::SINT64 || _rep->_isArray)

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

throw TypeMismatch();

x = _rep->_u._sint64Value;

Line 1531

Line 1203

void CIMValue::get(Real32& x) const

{

if (_rep->_type != CIMType::REAL32 || _rep->_isArray)

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

throw TypeMismatch();

x = _rep->_u._real32Value;

Line 1539

Line 1211

void CIMValue::get(Real64& x) const

{

if (_rep->_type != CIMType::REAL64 || _rep->_isArray)

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

throw TypeMismatch();

x = _rep->_u._real64Value;

Line 1547

Line 1219

void CIMValue::get(Char16& x) const

{

if (_rep->_type != CIMType::CHAR16 || _rep->_isArray)

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

throw TypeMismatch();

x = _rep->_u._char16Value;

Line 1555

Line 1227

void CIMValue::get(String& x) const

{

if (_rep->_type != CIMType::STRING || _rep->_isArray)

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

throw TypeMismatch();

x = *_rep->_u._stringValue;

Line 1563

Line 1235

void CIMValue::get(CIMDateTime& x) const

{

if (_rep->_type != CIMType::DATETIME || _rep->_isArray)

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

throw TypeMismatch();

x = *_rep->_u._dateTimeValue;

}

void CIMValue::get(CIMReference& x) const

void CIMValue::get(CIMObjectPath& x) const

{

if (_rep->_type != CIMType::REFERENCE || _rep->_isArray)

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

throw TypeMismatch();

x = *_rep->_u._referenceValue;

Line 1579

Line 1251

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

{

if (_rep->_type != CIMType::BOOLEAN || !_rep->_isArray)

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

throw TypeMismatch();

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

x = *_rep->_u._booleanArray;

}

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

{

if (_rep->_type != CIMType::UINT8 || !_rep->_isArray)

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

throw TypeMismatch();

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

x = *_rep->_u._uint8Array;

}

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

{

if (_rep->_type != CIMType::SINT8 || !_rep->_isArray)

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

throw TypeMismatch();

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

x = *_rep->_u._sint8Array;

}

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

{

if (_rep->_type != CIMType::UINT16 || !_rep->_isArray)

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

throw TypeMismatch();

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

x = *_rep->_u._uint16Array;

}

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

{

if (_rep->_type != CIMType::SINT16 || !_rep->_isArray)

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

throw TypeMismatch();

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

x = *_rep->_u._sint16Array;

}

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

{

if (_rep->_type != CIMType::UINT32 || !_rep->_isArray)

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

throw TypeMismatch();

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

x = *_rep->_u._uint32Array;

}

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

{

if (_rep->_type != CIMType::SINT32 || !_rep->_isArray)

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

throw TypeMismatch();

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

x = *_rep->_u._sint32Array;

}

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

{

if (_rep->_type != CIMType::UINT64 || !_rep->_isArray)

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

throw TypeMismatch();

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

x = *_rep->_u._uint64Array;

}

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

{

if (_rep->_type != CIMType::SINT64 || !_rep->_isArray)

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

throw TypeMismatch();

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

x = *_rep->_u._sint64Array;

}

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

{

if (_rep->_type != CIMType::REAL32 || !_rep->_isArray)

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

throw TypeMismatch();

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

x = *_rep->_u._real32Array;

}

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

{

if (_rep->_type != CIMType::REAL64 || !_rep->_isArray)

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

throw TypeMismatch();

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

x = *_rep->_u._real64Array;

}

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

{

if (_rep->_type != CIMType::CHAR16 || !_rep->_isArray)

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

throw TypeMismatch();

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

x = *_rep->_u._char16Array;

}

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

{

if (_rep->_type != CIMType::STRING || !_rep->_isArray)

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

throw TypeMismatch();

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

x = *_rep->_u._stringArray;

}

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

{

#ifdef CIMValueisNullexception

// ATTN-RK-20020815: Use UninitializedObject exception here if CIMValue is null?

if (_rep->_isNull)

throw CIMValueIsNull();

#endif

if (_rep->_type != CIMType::DATETIME || !_rep->_isArray)

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

throw TypeMismatch();

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

x = *_rep->_u._dateTimeArray;

}

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

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

{

if (_rep->_type != CIMType::REFERENCE || !_rep->_isArray)

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

throw TypeMismatch();

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

x = *_rep->_u._referenceArray;

}

CIMValue CIMValue::clone() const

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

{

return CIMValue(*this);

if (!typeCompatible(x))

}

return false;

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

{

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

Note that it output absolutely nothing. This works for

everything except qualifiers where the value tag is required in

any case per the XML specification

The DMTF has approved a change to the XML Specification

that extends the XML Definition to allow the

specification of NULL qualifier values. (CR812)

The definition of the ELEMENT QUALIFIER is now

defined as ...

<!ELEMENT QUALIFIER ((VALUE|VALUE.ARRAY)?)>

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

return false;

if (_rep->_isNull)

{

return;

}

if (_rep->_isArray)

{

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

{

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

_toXml(out, _rep->_u._booleanArray->data(),

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

_rep->_u._booleanArray->size);

// ATTN-RK-P3-20020220: Is there a reason to do it this way?

case CIMTYPE_UINT8:

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

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

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

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

//{

// out << "<VALUE>";

case CIMTYPE_SINT8:

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

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

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

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

//}

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

case CIMTYPE_UINT16:

break;

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

}

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

case CIMType::UINT8:

case CIMTYPE_SINT16:

_toXml(out, _rep->_u._uint8Array->data(),

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

_rep->_u._uint8Array->size);

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

break;

case CIMTYPE_UINT32:

case CIMType::SINT8:

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

_toXml(out, _rep->_u._sint8Array->data(),

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

_rep->_u._sint8Array->size);

break;

case CIMTYPE_SINT32:

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

case CIMType::UINT16:

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

_toXml(out, _rep->_u._uint16Array->data(),

_rep->_u._uint16Array->size);

case CIMTYPE_UINT64:

break;

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

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

case CIMType::SINT16:

_toXml(out, _rep->_u._sint16Array->data(),

case CIMTYPE_SINT64:

_rep->_u._sint16Array->size);

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

break;

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

case CIMType::UINT32:

case CIMTYPE_REAL32:

_toXml(out, _rep->_u._uint32Array->data(),

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

_rep->_u._uint32Array->size);

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

break;

case CIMTYPE_REAL64:

case CIMType::SINT32:

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

_toXml(out, _rep->_u._sint32Array->data(),

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

_rep->_u._sint32Array->size);

break;

case CIMTYPE_CHAR16:

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

case CIMType::UINT64:

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

_toXml(out, _rep->_u._uint64Array->data(),

_rep->_u._uint64Array->size);

case CIMTYPE_STRING:

break;

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

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

case CIMType::SINT64:

_toXml(out, _rep->_u._sint64Array->data(),

case CIMTYPE_DATETIME:

_rep->_u._sint64Array->size);

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

break;

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

case CIMType::REAL32:

case CIMTYPE_REFERENCE:

_toXml(out, _rep->_u._real32Array->data(),

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

_rep->_u._real32Array->size);

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

break;

case CIMType::REAL64:

_toXml(out, _rep->_u._real64Array->data(),

_rep->_u._real64Array->size);

break;

case CIMType::CHAR16:

_toXml(out, _rep->_u._char16Array->data(),

_rep->_u._char16Array->size);

break;

case CIMType::STRING:

_toXml(out, _rep->_u._stringArray->data(),

_rep->_u._stringArray->size);

break;

case CIMType::DATETIME:

_toXml(out, _rep->_u._dateTimeArray->data(),

_rep->_u._dateTimeArray->size);

break;

case CIMType::REFERENCE:

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

_rep->_u._referenceArray->size);

break;

default:

throw CIMValueInvalidType();

}

else if (_rep->_type == CIMType::REFERENCE)

{

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

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

}

else

{

out << "<VALUE>";

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

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

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

break;

case CIMType::UINT8:

case CIMTYPE_UINT8:

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

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

break;

case CIMType::SINT8:

case CIMTYPE_SINT8:

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

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

break;

case CIMType::UINT16:

case CIMTYPE_UINT16:

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

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

break;

case CIMType::SINT16:

case CIMTYPE_SINT16:

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

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

break;

case CIMType::UINT32:

case CIMTYPE_UINT32:

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

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

break;

case CIMType::SINT32:

case CIMTYPE_SINT32:

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

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

break;

case CIMType::UINT64:

case CIMTYPE_UINT64:

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

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

break;

case CIMType::SINT64:

case CIMTYPE_SINT64:

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

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

break;

case CIMType::REAL32:

case CIMTYPE_REAL32:

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

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

break;

case CIMType::REAL64:

case CIMTYPE_REAL64:

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

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

break;

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

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

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

break;

case CIMType::STRING:

case CIMTYPE_STRING:

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

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

break;

*x._rep->_u._stringValue);

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

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

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

break;

default:

throw CIMValueInvalidType();

}

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

case CIMTYPE_REFERENCE:

}

return *_rep->_u._referenceValue ==

}

*x._rep->_u._referenceValue;

String CIMValue::toXml() const

{

Array<Sint8> out;

toXml(out);

out.append('\0');

return String(out.getData());

}

void CIMValue::print(PEGASUS_STD(ostream) &os) const

{

Array<Sint8> tmp;

toXml(tmp);

tmp.append('\0');

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

}

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

{

// if the CIMValue is Null we return nothing.

// The alternative is to return the Null indicator.

if (_rep->_isNull)

{

out << "null";

return ;

}

if (_rep->_isArray)

{

switch (_rep->_type)

{

case CIMType::BOOLEAN:

{

_toMof(out, _rep->_u._booleanArray->data(),

_rep->_u._booleanArray->size);

break;

}

case CIMType::UINT8:

_toMof(out, _rep->_u._uint8Array->data(),

_rep->_u._uint8Array->size);

break;

case CIMType::SINT8:

_toMof(out, _rep->_u._sint8Array->data(),

_rep->_u._sint8Array->size);

break;

case CIMType::UINT16:

_toMof(out, _rep->_u._uint16Array->data(),

_rep->_u._uint16Array->size);

break;

case CIMType::SINT16:

_toMof(out, _rep->_u._sint16Array->data(),

_rep->_u._sint16Array->size);

break;

case CIMType::UINT32:

_toMof(out, _rep->_u._uint32Array->data(),

_rep->_u._uint32Array->size);

break;

case CIMType::SINT32:

_toMof(out, _rep->_u._sint32Array->data(),

_rep->_u._sint32Array->size);

break;

case CIMType::UINT64:

_toMof(out, _rep->_u._uint64Array->data(),

_rep->_u._uint64Array->size);

break;

case CIMType::SINT64:

_toMof(out, _rep->_u._sint64Array->data(),

_rep->_u._sint64Array->size);

break;

case CIMType::REAL32:

_toMof(out, _rep->_u._real32Array->data(),

_rep->_u._real32Array->size);

break;

case CIMType::REAL64:

_toMof(out, _rep->_u._real64Array->data(),

_rep->_u._real64Array->size);

break;

case CIMType::CHAR16:

_toMof(out, _rep->_u._char16Array->data(),

_rep->_u._char16Array->size);

break;

case CIMType::STRING:

_toMof(out, _rep->_u._stringArray->data(),

_rep->_u._stringArray->size);

break;

case CIMType::DATETIME:

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

_rep->_u._dateTimeArray->size);

break;

case CIMType::REFERENCE:

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

_rep->_u._referenceArray->size);

break;

default:

throw CIMValueInvalidType();

}

else

{

switch (_rep->_type)

{

case CIMType::BOOLEAN:

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

break;

case CIMType::UINT8:

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

break;

case CIMType::SINT8:

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

break;

case CIMType::UINT16:

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

break;

case CIMType::SINT16:

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

break;

case CIMType::UINT32:

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

break;

case CIMType::SINT32:

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

break;

case CIMType::UINT64:

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

break;

case CIMType::SINT64:

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

break;

case CIMType::REAL32:

// Unreachable!

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

return false;

break;

case CIMType::REAL64:

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

break;

case CIMType::CHAR16:

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

break;

case CIMType::STRING:

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

break;

case CIMType::DATETIME:

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

break;

case CIMType::REFERENCE:

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

break;

default:

throw CIMValueInvalidType();

}

String CIMValue::toString() const

Line 2091

Line 1519

{

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

{

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

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

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

{

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

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

out << " ";

}

break;

}

case CIMType::UINT8:

case CIMTYPE_UINT8:

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

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

_rep->_u._uint8Array->size);

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

break;

case CIMType::SINT8:

case CIMTYPE_SINT8:

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

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

_rep->_u._sint8Array->size);

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

break;

case CIMType::UINT16:

case CIMTYPE_UINT16:

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

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

_rep->_u._uint16Array->size);

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

break;

case CIMType::SINT16:

case CIMTYPE_SINT16:

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

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

_rep->_u._sint16Array->size);

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

break;

case CIMType::UINT32:

case CIMTYPE_UINT32:

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

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

_rep->_u._uint32Array->size);

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

break;

case CIMType::SINT32:

case CIMTYPE_SINT32:

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

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

_rep->_u._sint32Array->size);

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

break;

case CIMType::UINT64:

case CIMTYPE_UINT64:

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

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

_rep->_u._uint64Array->size);

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

break;

case CIMType::SINT64:

case CIMTYPE_SINT64:

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

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

_rep->_u._sint64Array->size);

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

break;

case CIMType::REAL32:

case CIMTYPE_REAL32:

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

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

_rep->_u._real32Array->size);

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

break;

case CIMType::REAL64:

case CIMTYPE_REAL64:

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

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

_rep->_u._real64Array->size);

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

break;

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

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

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

_rep->_u._char16Array->size);

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

break;

case CIMType::STRING:

case CIMTYPE_STRING:

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

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

_rep->_u._stringArray->size);

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

break;

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

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

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

_rep->_u._dateTimeArray->size);

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

break;

case CIMType::REFERENCE:

case CIMTYPE_REFERENCE:

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

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

_rep->_u._referenceArray->size);

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

break;

default:

Line 2180

Line 1608

{

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

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

break;

case CIMType::UINT8:

case CIMTYPE_UINT8:

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

break;

case CIMType::SINT8:

case CIMTYPE_SINT8:

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

break;

case CIMType::UINT16:

case CIMTYPE_UINT16:

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

break;

case CIMType::SINT16:

case CIMTYPE_SINT16:

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

break;

case CIMType::UINT32:

case CIMTYPE_UINT32:

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

break;

case CIMType::SINT32:

case CIMTYPE_SINT32:

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

break;

case CIMType::UINT64:

case CIMTYPE_UINT64:

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

break;

case CIMType::SINT64:

case CIMTYPE_SINT64:

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

break;

case CIMType::REAL32:

case CIMTYPE_REAL32:

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

break;

case CIMType::REAL64:

case CIMTYPE_REAL64:

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

break;

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

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

break;

case CIMType::STRING:

case CIMTYPE_STRING:

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

break;

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

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

break;

case CIMType::REFERENCE:

case CIMTYPE_REFERENCE:

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

break;

Line 2252

Line 1680

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

{

if (!x.typeCompatible(y))

return x.equal(y);

return false;

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

return false;

if (x._rep->_isArray)

{

switch (x._rep->_type)

{

case CIMType::BOOLEAN:

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

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

case CIMType::UINT8:

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

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

case CIMType::SINT8:

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

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

case CIMType::UINT16:

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

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

case CIMType::SINT16:

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

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

case CIMType::UINT32:

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

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

case CIMType::SINT32:

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

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

case CIMType::UINT64:

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

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

case CIMType::SINT64:

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

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

case CIMType::REAL32:

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

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

case CIMType::REAL64:

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

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

case CIMType::CHAR16:

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

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

case CIMType::STRING:

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

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

case CIMType::DATETIME:

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

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

case CIMType::REFERENCE:

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

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

default:

throw CIMValueInvalidType();

}

else

{

switch (x._rep->_type)

{

case CIMType::BOOLEAN:

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

case CIMType::UINT8:

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

case CIMType::SINT8:

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

case CIMType::UINT16:

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

case CIMType::SINT16:

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

case CIMType::UINT32:

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

case CIMType::SINT32:

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

case CIMType::UINT64:

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

case CIMType::SINT64:

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

case CIMType::REAL32:

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

case CIMType::REAL64:

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

case CIMType::CHAR16:

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

case CIMType::STRING:

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

*y._rep->_u._stringValue);

case CIMType::DATETIME:

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

case CIMType::REFERENCE:

return *x._rep->_u._referenceValue ==

*y._rep->_u._referenceValue;

default:

throw CIMValueInvalidType();

}

// Unreachable!

return false;

}

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

{

return !operator==(x, y);

return !x.equal(y);

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.28
changed lines
	Added in v.1.37

No CVS admin address has been configured