version 1.27, 2002/05/11 21:36:29
|
version 1.49.4.1, 2004/11/12 17:48:28
|
|
|
//%///////////////////////////////////////////////////////////////////////////// |
//%2003//////////////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM |
// Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Development |
|
// Company, L. P., IBM Corp., The Open Group, Tivoli Systems. |
|
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; |
|
// IBM Corp.; EMC Corporation, The Open Group. |
// | // |
// Permission is hereby granted, free of charge, to any person obtaining a copy | // Permission is hereby granted, free of charge, to any person obtaining a copy |
// of this software and associated documentation files (the "Software"), to | // of this software and associated documentation files (the "Software"), to |
|
|
// | // |
// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) | // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) |
// Karl Schopmeyer, (k.schopmeyer@opengroup.org) | // Karl Schopmeyer, (k.schopmeyer@opengroup.org) |
|
// Carol Ann Krug Graves, Hewlett-Packard Company |
|
// (carolann_graves@hp.com) |
|
// Adriann Schuur (schuur@de.ibm.com) PEP 164 |
// | // |
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
#include <cstring> | #include <cstring> |
#include <cstdio> | #include <cstdio> |
#include <cassert> |
|
#include <cctype> | #include <cctype> |
#include "CIMValue.h" | #include "CIMValue.h" |
#include "Union.h" | #include "Union.h" |
#include "Indentor.h" | #include "Indentor.h" |
#include "XmlWriter.h" | #include "XmlWriter.h" |
|
#include "CommonUTF.h" |
|
|
|
#include "CIMValueRep.h" |
| |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
|
|
# include "ArrayImpl.h" | # include "ArrayImpl.h" |
#undef PEGASUS_ARRAY_T | #undef PEGASUS_ARRAY_T |
| |
template<class T> |
|
inline void _Inc(ArrayRep<T>* rep) |
|
{ |
|
ArrayRep<T>::inc(rep); |
|
} |
|
|
|
template<class T> |
|
inline void _Dec(ArrayRep<T>* rep) |
|
{ |
|
ArrayRep<T>::dec(rep); |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
// |
|
// Local helper functions: |
|
// |
|
//////////////////////////////////////////////////////////////////////////////// |
|
|
|
// Too complicated. Commented out in favor of sprintf("%lld"/"%llu"). |
|
#if 0 |
|
//------------------------------------------------------------------------------ |
|
// |
|
// _SignedIntToStr() |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
static void _SignedIntToStr(Sint64 x, char* result) |
|
{ |
|
if (!result) |
|
return; |
|
|
|
if (x == 0) |
|
{ |
|
result[0] = '0'; |
|
result[1] = '\0'; |
|
return; |
|
} |
|
|
|
char buffer[32]; |
|
Uint32 len = 0; |
|
Boolean negative = false; |
|
|
|
while (x) |
|
{ |
|
Sint32 r = x % 10; |
|
x = x / 10; |
|
|
|
if (r < 0) |
|
{ |
|
r = -r; |
|
negative = true; |
|
} |
|
|
|
buffer[len++] = r + '0'; |
|
} |
|
|
|
buffer[len] = '\0'; |
|
|
|
// If buffer was negative, prepend sign: |
|
|
|
char* q = result; |
|
| |
if (negative) |
|
*q++ = '-'; |
|
|
|
// Reverse the buffer: |
|
|
|
char* p = &buffer[len]; |
|
|
|
while (len--) |
|
*q++ = *--p; |
|
|
|
*q++ = '\0'; |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// | // |
// _UnsignedIntToStr() |
// _toString routines: |
// | // |
//------------------------------------------------------------------------------ |
//////////////////////////////////////////////////////////////////////////////// |
|
|
static void _UnsignedIntToStr(Uint64 x, char* result) |
|
{ |
|
if (!result) |
|
return; |
|
|
|
if (x == 0) |
|
{ |
|
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) | 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 _toString(Array<Sint8>& out, Uint8 x) { XmlWriter::append(out, Uint32(x)); } |
inline void _toMof(Array<Sint8>& out, Boolean x) { _toString(out, x); } |
inline void _toString(Array<Sint8>& out, Sint8 x) { XmlWriter::append(out, Sint32(x)); } |
|
inline void _toString(Array<Sint8>& out, Uint16 x) { XmlWriter::append(out, Uint32(x)); } |
inline void _integerToString(Array<Sint8>& out, Sint32 x) |
inline void _toString(Array<Sint8>& out, Sint16 x) { XmlWriter::append(out, Sint32(x)); } |
{ |
inline void _toString(Array<Sint8>& out, Uint32 x) { XmlWriter::append(out, x); } |
char buffer[32]; |
inline void _toString(Array<Sint8>& out, Sint32 x) { XmlWriter::append(out, x); } |
sprintf(buffer, "%d", x); |
inline void _toString(Array<Sint8>& out, Uint64 x) { XmlWriter::append(out, x); } |
out << (char*)buffer; |
inline void _toString(Array<Sint8>& out, Sint64 x) { XmlWriter::append(out, x); } |
} |
inline void _toString(Array<Sint8>& out, Real32 x) { XmlWriter::append(out, Real64(x)); } |
|
inline void _toString(Array<Sint8>& out, Real64 x) { XmlWriter::append(out, x); } |
inline void _unsignedIntegerToString(Array<Sint8>& out, Uint32 x) |
|
{ |
|
char buffer[32]; |
|
sprintf(buffer, "%u", x); |
|
out << (char*)buffer; |
|
} |
|
|
|
inline void _toString(Array<Sint8>& out, Uint8 x) { _unsignedIntegerToString(out, 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 |
|
// 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) | inline void _toString(Array<Sint8>& out, Char16 x) |
{ | { |
// ATTN: How to convert 16-bit characters to printable form? |
// We need to convert the Char16 to UTF8 then append the UTF8 |
out.append(Sint8(x)); |
// character into the array. |
} |
// NOTE: The UTF8 character could be several bytes long. |
inline void _toXml(Array<Sint8>& out, Char16 x) |
// WARNING: This function will put in replacement character for |
{ |
// all characters that have surogate pairs. |
XmlWriter::appendSpecial(out, x); |
|
} |
char str[6]; |
inline void _toMof(Array<Sint8>& out, Char16 x) |
memset(str,0x00,sizeof(str)); |
{ |
char* charIN = (char *)&x; |
XmlWriter::appendSpecial(out, x); |
|
|
const Uint16 *strsrc = (Uint16 *)charIN; |
|
Uint16 *endsrc = (Uint16 *)&charIN[1]; |
|
|
|
Uint8 *strtgt = (Uint8 *)str; |
|
Uint8 *endtgt = (Uint8 *)&str[5]; |
|
|
|
UTF16toUTF8(&strsrc, |
|
endsrc, |
|
&strtgt, |
|
endtgt); |
|
|
|
out.append((Sint8 *)str, UTF_8_COUNT_TRAIL_BYTES(str[0]) +1); |
} | } |
| |
inline void _toString(Array<Sint8>& out, const String& x) | inline void _toString(Array<Sint8>& out, const String& x) |
|
|
out << 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) | inline void _toString(Array<Sint8>& out, const CIMDateTime& x) |
{ | { |
out << x.getString(); |
out << x.toString(); |
} | } |
| |
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(); | out << x.toString(); |
} | } |
inline void _toXml(Array<Sint8>& out, const CIMReference& x) |
|
{ |
inline void _toString(Array<Sint8>& out, const CIMObject& x) |
x.toXml(out); |
|
} |
|
inline void _toMof(Array<Sint8>& out, const CIMReference& x) |
|
{ | { |
x.toMof(out); |
out << x.toString(); |
} | } |
| |
template<class T> | template<class T> |
|
|
} | } |
} | } |
| |
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 << "}"; |
|
|
|
} |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// CIMValueRep |
|
// |
|
//////////////////////////////////////////////////////////////////////////////// |
|
|
|
class CIMValueRep |
|
{ |
|
public: |
|
CIMValueRep() |
|
{ |
|
reset(); |
|
} |
|
|
|
~CIMValueRep() |
|
{ |
|
} |
|
|
|
void reset() |
|
{ |
|
_type = CIMType::NONE; |
|
_isArray = false; |
|
_isNull = true; |
|
_u._voidPtr = 0; |
|
} |
|
|
|
CIMType _type; |
|
Boolean _isArray; |
|
Boolean _isNull; |
|
Union _u; |
|
}; |
|
|
|
| |
//////////////////////////////////////////////////////////////////////////////// | //////////////////////////////////////////////////////////////////////////////// |
// | // |
|
|
set(x); | set(x); |
} | } |
| |
CIMValue::CIMValue(const char* x) |
CIMValue::CIMValue(const CIMDateTime& x) |
{ | { |
_rep = new CIMValueRep(); | _rep = new CIMValueRep(); |
set(x); | set(x); |
} | } |
| |
CIMValue::CIMValue(const CIMDateTime& x) |
CIMValue::CIMValue(const CIMObjectPath& x) |
{ | { |
_rep = new CIMValueRep(); | _rep = new CIMValueRep(); |
set(x); | set(x); |
} | } |
| |
CIMValue::CIMValue(const CIMReference& x) |
CIMValue::CIMValue(const CIMObject& x) |
{ | { |
_rep = new CIMValueRep(); | _rep = new CIMValueRep(); |
set(x); | set(x); |
|
|
set(x); | set(x); |
} | } |
| |
CIMValue::CIMValue(const Array<CIMReference>& x) |
CIMValue::CIMValue(const Array<CIMObjectPath>& x) |
|
{ |
|
_rep = new CIMValueRep(); |
|
set(x); |
|
} |
|
|
|
CIMValue::CIMValue(const Array<CIMObject>& x) |
{ | { |
_rep = new CIMValueRep(); | _rep = new CIMValueRep(); |
set(x); | set(x); |
|
|
_rep->_type = x._rep->_type; | _rep->_type = x._rep->_type; |
_rep->_isArray = x._rep->_isArray; | _rep->_isArray = x._rep->_isArray; |
_rep->_isNull = x._rep->_isNull; | _rep->_isNull = x._rep->_isNull; |
_rep->_u._voidPtr = 0; |
|
| |
if (_rep->_isArray) | if (_rep->_isArray) |
{ | { |
switch (_rep->_type) | 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; | 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; | 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; | 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; | 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; | 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; | 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; | 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; | 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; | 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; | 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; | 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; | 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; | 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; | 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; | break; |
|
|
|
case CIMTYPE_OBJECT: |
|
_rep->_u._cimobjectArray = |
|
new Array<CIMObject>(*(x._rep->_u._cimobjectArray)); |
|
break; |
|
|
default: | default: |
throw CIMValueInvalidType(); |
PEGASUS_ASSERT(false); |
} | } |
} | } |
else | else |
{ | { |
switch (_rep->_type) | switch (_rep->_type) |
{ | { |
case CIMType::NONE: |
case CIMTYPE_BOOLEAN: |
break; |
|
|
|
case CIMType::BOOLEAN: |
|
_rep->_u._booleanValue = x._rep->_u._booleanValue; | _rep->_u._booleanValue = x._rep->_u._booleanValue; |
break; | break; |
| |
case CIMType::UINT8: |
case CIMTYPE_UINT8: |
_rep->_u._uint8Value = x._rep->_u._uint8Value; | _rep->_u._uint8Value = x._rep->_u._uint8Value; |
break; | break; |
| |
case CIMType::SINT8: |
case CIMTYPE_SINT8: |
_rep->_u._sint8Value = x._rep->_u._sint8Value; | _rep->_u._sint8Value = x._rep->_u._sint8Value; |
break; | break; |
| |
case CIMType::UINT16: |
case CIMTYPE_UINT16: |
_rep->_u._uint16Value = x._rep->_u._uint16Value; | _rep->_u._uint16Value = x._rep->_u._uint16Value; |
break; | break; |
| |
case CIMType::SINT16: |
case CIMTYPE_SINT16: |
_rep->_u._sint16Value = x._rep->_u._sint16Value; | _rep->_u._sint16Value = x._rep->_u._sint16Value; |
break; | break; |
| |
case CIMType::UINT32: |
case CIMTYPE_UINT32: |
_rep->_u._uint32Value = x._rep->_u._uint32Value; | _rep->_u._uint32Value = x._rep->_u._uint32Value; |
break; | break; |
| |
case CIMType::SINT32: |
case CIMTYPE_SINT32: |
_rep->_u._sint32Value = x._rep->_u._sint32Value; | _rep->_u._sint32Value = x._rep->_u._sint32Value; |
break; | break; |
| |
case CIMType::UINT64: |
case CIMTYPE_UINT64: |
_rep->_u._uint64Value = x._rep->_u._uint64Value; | _rep->_u._uint64Value = x._rep->_u._uint64Value; |
break; | break; |
| |
case CIMType::SINT64: |
case CIMTYPE_SINT64: |
_rep->_u._sint64Value = x._rep->_u._sint64Value; | _rep->_u._sint64Value = x._rep->_u._sint64Value; |
break; | break; |
| |
case CIMType::REAL32: |
case CIMTYPE_REAL32: |
_rep->_u._real32Value = x._rep->_u._real32Value; | _rep->_u._real32Value = x._rep->_u._real32Value; |
break; | break; |
| |
case CIMType::REAL64: |
case CIMTYPE_REAL64: |
_rep->_u._real64Value = x._rep->_u._real64Value; | _rep->_u._real64Value = x._rep->_u._real64Value; |
break; | break; |
| |
case CIMType::CHAR16: |
case CIMTYPE_CHAR16: |
_rep->_u._char16Value = x._rep->_u._char16Value; | _rep->_u._char16Value = x._rep->_u._char16Value; |
break; | break; |
| |
case CIMType::STRING: |
case CIMTYPE_STRING: |
_rep->_u._stringValue = new String(*(x._rep->_u._stringValue)); | _rep->_u._stringValue = new String(*(x._rep->_u._stringValue)); |
break; | break; |
| |
case CIMType::DATETIME: |
case CIMTYPE_DATETIME: |
_rep->_u._dateTimeValue = | _rep->_u._dateTimeValue = |
new CIMDateTime(*(x._rep->_u._dateTimeValue)); | new CIMDateTime(*(x._rep->_u._dateTimeValue)); |
break; | break; |
| |
case CIMType::REFERENCE: |
case CIMTYPE_REFERENCE: |
_rep->_u._referenceValue = | _rep->_u._referenceValue = |
new CIMReference(*(x._rep->_u._referenceValue)); |
new CIMObjectPath(*(x._rep->_u._referenceValue)); |
|
break; |
|
|
|
case CIMTYPE_OBJECT: |
|
_rep->_u._cimobjectValue = |
|
new CIMObject(x._rep->_u._cimobjectValue->clone()); |
break; | break; |
| |
// Should never get here. testing complete enum | // Should never get here. testing complete enum |
default: | default: |
throw CIMValueInvalidType(); |
PEGASUS_ASSERT(false); |
} | } |
} | } |
} | } |
| |
//ATTN: P1 KS Problem with Compiler when I added the defaults to clear, the compiler |
|
// gets an exception very early. Disabled the exceptions to keep compiler running for |
|
// the minute. Note that the case statement is not complete. None missing. |
|
void CIMValue::clear() | void CIMValue::clear() |
{ | { |
if (_rep->_isArray) | if (_rep->_isArray) |
{ | { |
switch (_rep->_type) | switch (_rep->_type) |
{ | { |
case CIMType::BOOLEAN: |
case CIMTYPE_BOOLEAN: |
_Dec(_rep->_u._booleanArray); |
delete _rep->_u._booleanArray; |
break; | break; |
| |
case CIMType::UINT8: |
case CIMTYPE_UINT8: |
_Dec(_rep->_u._uint8Array); |
delete _rep->_u._uint8Array; |
break; | break; |
| |
case CIMType::SINT8: |
case CIMTYPE_SINT8: |
_Dec(_rep->_u._sint8Array); |
delete _rep->_u._sint8Array; |
break; | break; |
| |
case CIMType::UINT16: |
case CIMTYPE_UINT16: |
_Dec(_rep->_u._uint16Array); |
delete _rep->_u._uint16Array; |
break; | break; |
| |
case CIMType::SINT16: |
case CIMTYPE_SINT16: |
_Dec(_rep->_u._sint16Array); |
delete _rep->_u._sint16Array; |
break; | break; |
| |
case CIMType::UINT32: |
case CIMTYPE_UINT32: |
_Dec(_rep->_u._uint32Array); |
delete _rep->_u._uint32Array; |
break; | break; |
| |
case CIMType::SINT32: |
case CIMTYPE_SINT32: |
_Dec(_rep->_u._sint32Array); |
delete _rep->_u._sint32Array; |
break; | break; |
| |
case CIMType::UINT64: |
case CIMTYPE_UINT64: |
_Dec(_rep->_u._uint64Array); |
delete _rep->_u._uint64Array; |
break; | break; |
| |
case CIMType::SINT64: |
case CIMTYPE_SINT64: |
_Dec(_rep->_u._sint64Array); |
delete _rep->_u._sint64Array; |
break; | break; |
| |
case CIMType::REAL32: |
case CIMTYPE_REAL32: |
_Dec(_rep->_u._real32Array); |
delete _rep->_u._real32Array; |
break; | break; |
| |
case CIMType::REAL64: |
case CIMTYPE_REAL64: |
_Dec(_rep->_u._real64Array); |
delete _rep->_u._real64Array; |
break; | break; |
| |
case CIMType::CHAR16: |
case CIMTYPE_CHAR16: |
_Dec(_rep->_u._char16Array); |
delete _rep->_u._char16Array; |
break; | break; |
| |
case CIMType::STRING: |
case CIMTYPE_STRING: |
_Dec(_rep->_u._stringArray); |
delete _rep->_u._stringArray; |
break; | break; |
| |
case CIMType::DATETIME: |
case CIMTYPE_DATETIME: |
_Dec(_rep->_u._dateTimeArray); |
delete _rep->_u._dateTimeArray; |
break; | break; |
| |
case CIMType::REFERENCE: |
case CIMTYPE_REFERENCE: |
_Dec(_rep->_u._referenceArray); |
delete _rep->_u._referenceArray; |
break; | break; |
| |
//default: |
case CIMTYPE_OBJECT: |
//throw CIMValueInvalidType(); |
delete _rep->_u._cimobjectArray; |
|
break; |
|
|
|
default: |
|
PEGASUS_ASSERT(false); |
} | } |
} | } |
else | else |
{ | { |
switch (_rep->_type) | 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; | break; |
| |
case CIMType::STRING: |
case CIMTYPE_STRING: |
delete _rep->_u._stringValue; | delete _rep->_u._stringValue; |
break; | break; |
| |
case CIMType::DATETIME: |
case CIMTYPE_DATETIME: |
delete _rep->_u._dateTimeValue; | delete _rep->_u._dateTimeValue; |
break; | break; |
| |
case CIMType::REFERENCE: |
case CIMTYPE_REFERENCE: |
delete _rep->_u._referenceValue; | delete _rep->_u._referenceValue; |
break; | break; |
//default: |
|
//throw CIMValueInvalidType(); |
case CIMTYPE_OBJECT: |
|
delete _rep->_u._cimobjectValue; |
|
break; |
|
|
|
default: |
|
PEGASUS_ASSERT(false); |
} | } |
} | } |
| |
|
|
| |
Boolean CIMValue::typeCompatible(const CIMValue& x) const | 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 | Boolean CIMValue::isArray() const |
|
|
| |
switch (_rep->_type) | switch (_rep->_type) |
{ | { |
case CIMType::NONE: |
case CIMTYPE_BOOLEAN: |
return 0; |
return _rep->_u._booleanArray->size(); |
break; | break; |
| |
case CIMType::BOOLEAN: |
case CIMTYPE_UINT8: |
return _rep->_u._booleanArray->size; |
return _rep->_u._uint8Array->size(); |
break; | break; |
| |
case CIMType::UINT8: |
case CIMTYPE_SINT8: |
return _rep->_u._uint8Array->size; |
return _rep->_u._sint8Array->size(); |
break; | break; |
| |
case CIMType::SINT8: |
case CIMTYPE_UINT16: |
return _rep->_u._sint8Array->size; |
return _rep->_u._uint16Array->size(); |
break; | break; |
| |
case CIMType::UINT16: |
case CIMTYPE_SINT16: |
return _rep->_u._uint16Array->size; |
return _rep->_u._sint16Array->size(); |
break; | break; |
| |
case CIMType::SINT16: |
case CIMTYPE_UINT32: |
return _rep->_u._sint16Array->size; |
return _rep->_u._uint32Array->size(); |
break; | break; |
| |
case CIMType::UINT32: |
case CIMTYPE_SINT32: |
return _rep->_u._uint32Array->size; |
return _rep->_u._sint32Array->size(); |
break; | break; |
| |
case CIMType::SINT32: |
case CIMTYPE_UINT64: |
return _rep->_u._sint32Array->size; |
return _rep->_u._uint64Array->size(); |
break; | break; |
| |
case CIMType::UINT64: |
case CIMTYPE_SINT64: |
return _rep->_u._uint64Array->size; |
return _rep->_u._sint64Array->size(); |
break; | break; |
| |
case CIMType::SINT64: |
case CIMTYPE_REAL32: |
return _rep->_u._sint64Array->size; |
return _rep->_u._real32Array->size(); |
break; | break; |
| |
case CIMType::REAL32: |
case CIMTYPE_REAL64: |
return _rep->_u._real32Array->size; |
return _rep->_u._real64Array->size(); |
break; | break; |
| |
case CIMType::REAL64: |
case CIMTYPE_CHAR16: |
return _rep->_u._real64Array->size; |
return _rep->_u._char16Array->size(); |
break; | break; |
| |
case CIMType::CHAR16: |
case CIMTYPE_STRING: |
return _rep->_u._char16Array->size; |
return _rep->_u._stringArray->size(); |
break; | break; |
| |
case CIMType::STRING: |
case CIMTYPE_DATETIME: |
return _rep->_u._stringArray->size; |
return _rep->_u._dateTimeArray->size(); |
break; | break; |
| |
case CIMType::DATETIME: |
case CIMTYPE_REFERENCE: |
return _rep->_u._dateTimeArray->size; |
return _rep->_u._referenceArray->size(); |
break; | break; |
| |
case CIMType::REFERENCE: |
case CIMTYPE_OBJECT: |
return _rep->_u._referenceArray->size; |
return _rep->_u._cimobjectArray->size(); |
break; | break; |
// Should never get here. switch on complete enum |
|
default: |
//default: // Handled below |
throw CIMValueInvalidType(); |
|
} | } |
| |
// Unreachable! | // Unreachable! |
|
|
| |
void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize) | void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize) |
{ | { |
|
|
clear(); | clear(); |
| |
if (isArray) | if (isArray) |
{ | { |
switch (type) | switch (type) |
{ | { |
case CIMType::BOOLEAN: |
case CIMTYPE_BOOLEAN: |
set(Array<Boolean>(arraySize)); | set(Array<Boolean>(arraySize)); |
break; | break; |
| |
case CIMType::UINT8: |
case CIMTYPE_UINT8: |
set(Array<Uint8>(arraySize)); | set(Array<Uint8>(arraySize)); |
break; | break; |
| |
case CIMType::SINT8: |
case CIMTYPE_SINT8: |
set(Array<Sint8>(arraySize)); | set(Array<Sint8>(arraySize)); |
break; | break; |
| |
case CIMType::UINT16: |
case CIMTYPE_UINT16: |
set(Array<Uint16>(arraySize)); | set(Array<Uint16>(arraySize)); |
break; | break; |
| |
case CIMType::SINT16: |
case CIMTYPE_SINT16: |
set(Array<Sint16>(arraySize)); | set(Array<Sint16>(arraySize)); |
break; | break; |
| |
case CIMType::UINT32: |
case CIMTYPE_UINT32: |
set(Array<Uint32>(arraySize)); | set(Array<Uint32>(arraySize)); |
break; | break; |
| |
case CIMType::SINT32: |
case CIMTYPE_SINT32: |
set(Array<Sint32>(arraySize)); | set(Array<Sint32>(arraySize)); |
break; | break; |
| |
case CIMType::UINT64: |
case CIMTYPE_UINT64: |
set(Array<Uint64>(arraySize)); | set(Array<Uint64>(arraySize)); |
break; | break; |
| |
case CIMType::SINT64: |
case CIMTYPE_SINT64: |
set(Array<Sint64>(arraySize)); | set(Array<Sint64>(arraySize)); |
break; | break; |
| |
case CIMType::REAL32: |
case CIMTYPE_REAL32: |
set(Array<Real32>(arraySize)); | set(Array<Real32>(arraySize)); |
break; | break; |
| |
case CIMType::REAL64: |
case CIMTYPE_REAL64: |
set(Array<Real64>(arraySize)); | set(Array<Real64>(arraySize)); |
break; | break; |
| |
case CIMType::CHAR16: |
case CIMTYPE_CHAR16: |
set(Array<Char16>(arraySize)); | set(Array<Char16>(arraySize)); |
break; | break; |
| |
case CIMType::STRING: |
case CIMTYPE_STRING: |
set(Array<String>(arraySize)); | set(Array<String>(arraySize)); |
break; | break; |
| |
case CIMType::DATETIME: |
case CIMTYPE_DATETIME: |
set(Array<CIMDateTime>(arraySize)); | set(Array<CIMDateTime>(arraySize)); |
break; | break; |
| |
case CIMType::REFERENCE: |
case CIMTYPE_REFERENCE: |
set(Array<CIMReference>(arraySize)); |
set(Array<CIMObjectPath>(arraySize)); |
|
break; |
|
|
|
case CIMTYPE_OBJECT: |
|
set(Array<CIMObject>(arraySize)); |
break; | break; |
|
|
default: | default: |
throw CIMValueInvalidType(); |
throw TypeMismatchException(); |
} | } |
} | } |
else | else |
{ | { |
switch (type) | switch (type) |
{ | { |
case CIMType::BOOLEAN: |
case CIMTYPE_BOOLEAN: |
set(false); | set(false); |
break; | break; |
| |
case CIMType::UINT8: |
case CIMTYPE_UINT8: |
set(Uint8(0)); | set(Uint8(0)); |
break; | break; |
| |
case CIMType::SINT8: |
case CIMTYPE_SINT8: |
set(Sint8(0)); | set(Sint8(0)); |
break; | break; |
| |
case CIMType::UINT16: |
case CIMTYPE_UINT16: |
set(Uint16(0)); | set(Uint16(0)); |
break; | break; |
| |
case CIMType::SINT16: |
case CIMTYPE_SINT16: |
set(Sint16(0)); | set(Sint16(0)); |
break; | break; |
| |
case CIMType::UINT32: |
case CIMTYPE_UINT32: |
set(Uint32(0)); | set(Uint32(0)); |
break; | break; |
| |
case CIMType::SINT32: |
case CIMTYPE_SINT32: |
set(Sint32(0)); | set(Sint32(0)); |
break; | break; |
| |
case CIMType::UINT64: |
case CIMTYPE_UINT64: |
set(Uint64(0)); | set(Uint64(0)); |
break; | break; |
| |
case CIMType::SINT64: |
case CIMTYPE_SINT64: |
set(Sint64(0)); | set(Sint64(0)); |
break; | break; |
| |
case CIMType::REAL32: |
case CIMTYPE_REAL32: |
set(Real32(0.0)); | set(Real32(0.0)); |
break; | break; |
| |
case CIMType::REAL64: |
case CIMTYPE_REAL64: |
set(Real64(0.0)); | set(Real64(0.0)); |
break; | break; |
| |
case CIMType::CHAR16: |
case CIMTYPE_CHAR16: |
set(Char16(0)); | set(Char16(0)); |
break; | break; |
| |
case CIMType::STRING: |
case CIMTYPE_STRING: |
set(String()); | set(String()); |
break; | break; |
| |
case CIMType::DATETIME: |
case CIMTYPE_DATETIME: |
set(CIMDateTime()); | set(CIMDateTime()); |
break; | break; |
| |
case CIMType::REFERENCE: |
case CIMTYPE_REFERENCE: |
set(CIMReference()); |
set(CIMObjectPath()); |
|
break; |
|
|
|
case CIMTYPE_OBJECT: |
|
set(CIMObject()); |
break; | break; |
|
|
default: | default: |
throw CIMValueInvalidType(); |
throw TypeMismatchException(); |
} | } |
} | } |
| |
|
|
{ | { |
clear(); | clear(); |
_rep->_u._booleanValue = (Uint8)x; | _rep->_u._booleanValue = (Uint8)x; |
_rep->_type = CIMType::BOOLEAN; |
_rep->_type = CIMTYPE_BOOLEAN; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
|
|
{ | { |
clear(); | clear(); |
_rep->_u._uint8Value = x; | _rep->_u._uint8Value = x; |
_rep->_type = CIMType::UINT8; |
_rep->_type = CIMTYPE_UINT8; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
|
|
{ | { |
clear(); | clear(); |
_rep->_u._sint8Value = x; | _rep->_u._sint8Value = x; |
_rep->_type = CIMType::SINT8; |
_rep->_type = CIMTYPE_SINT8; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
|
|
{ | { |
clear(); | clear(); |
_rep->_u._uint16Value = x; | _rep->_u._uint16Value = x; |
_rep->_type = CIMType::UINT16; |
_rep->_type = CIMTYPE_UINT16; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
|
|
{ | { |
clear(); | clear(); |
_rep->_u._sint16Value = x; | _rep->_u._sint16Value = x; |
_rep->_type = CIMType::SINT16; |
_rep->_type = CIMTYPE_SINT16; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
|
|
{ | { |
clear(); | clear(); |
_rep->_u._uint32Value = x; | _rep->_u._uint32Value = x; |
_rep->_type = CIMType::UINT32; |
_rep->_type = CIMTYPE_UINT32; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
|
|
{ | { |
clear(); | clear(); |
_rep->_u._sint32Value = x; | _rep->_u._sint32Value = x; |
_rep->_type = CIMType::SINT32; |
_rep->_type = CIMTYPE_SINT32; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
|
|
{ | { |
clear(); | clear(); |
_rep->_u._uint64Value = x; | _rep->_u._uint64Value = x; |
_rep->_type = CIMType::UINT64; |
_rep->_type = CIMTYPE_UINT64; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
|
|
{ | { |
clear(); | clear(); |
_rep->_u._sint64Value = x; | _rep->_u._sint64Value = x; |
_rep->_type = CIMType::SINT64; |
_rep->_type = CIMTYPE_SINT64; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
|
|
{ | { |
clear(); | clear(); |
_rep->_u._real32Value = x; | _rep->_u._real32Value = x; |
_rep->_type = CIMType::REAL32; |
_rep->_type = CIMTYPE_REAL32; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
|
|
{ | { |
clear(); | clear(); |
_rep->_u._real64Value = x; | _rep->_u._real64Value = x; |
_rep->_type = CIMType::REAL64; |
_rep->_type = CIMTYPE_REAL64; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
|
|
{ | { |
clear(); | clear(); |
_rep->_u._char16Value = x; | _rep->_u._char16Value = x; |
_rep->_type = CIMType::CHAR16; |
_rep->_type = CIMTYPE_CHAR16; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
|
|
{ | { |
clear(); | clear(); |
_rep->_u._stringValue = new String(x); | _rep->_u._stringValue = new String(x); |
_rep->_type = CIMType::STRING; |
_rep->_type = CIMTYPE_STRING; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
void CIMValue::set(const char* x) |
void CIMValue::set(const CIMDateTime& x) |
{ | { |
set(String(x)); |
clear(); |
|
_rep->_u._dateTimeValue = new CIMDateTime(x); |
|
_rep->_type = CIMTYPE_DATETIME; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
void CIMValue::set(const CIMDateTime& x) |
void CIMValue::set(const CIMObjectPath& x) |
{ | { |
clear(); | clear(); |
_rep->_u._dateTimeValue = new CIMDateTime(x); |
_rep->_u._referenceValue = new CIMObjectPath(x); |
_rep->_type = CIMType::DATETIME; |
_rep->_type = CIMTYPE_REFERENCE; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
void CIMValue::set(const CIMReference& x) |
void CIMValue::set(const CIMObject& x) |
{ | { |
clear(); | clear(); |
_rep->_u._referenceValue = new CIMReference(x); |
if (x.isUninitialized()) { |
_rep->_type = CIMType::REFERENCE; |
// Don't need to clone since null CIMObjects aren't shared when created. |
|
// Doesn't work anyway, clone() throws an exception if null. |
|
_rep->_u._cimobjectValue = new CIMObject(x); |
|
} |
|
else { |
|
_rep->_u._cimobjectValue = new CIMObject(x.clone()); |
|
} |
|
_rep->_type = CIMTYPE_OBJECT; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
void CIMValue::set(const Array<Boolean>& x) | void CIMValue::set(const Array<Boolean>& x) |
{ | { |
clear(); | 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->_isArray = true; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
|
|
void CIMValue::set(const Array<Uint8>& x) | void CIMValue::set(const Array<Uint8>& x) |
{ | { |
clear(); | 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->_isArray = true; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
|
|
void CIMValue::set(const Array<Sint8>& x) | void CIMValue::set(const Array<Sint8>& x) |
{ | { |
clear(); | 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->_isArray = true; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
|
|
void CIMValue::set(const Array<Uint16>& x) | void CIMValue::set(const Array<Uint16>& x) |
{ | { |
clear(); | 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->_isArray = true; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
|
|
void CIMValue::set(const Array<Sint16>& x) | void CIMValue::set(const Array<Sint16>& x) |
{ | { |
clear(); | 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->_isArray = true; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
|
|
void CIMValue::set(const Array<Uint32>& x) | void CIMValue::set(const Array<Uint32>& x) |
{ | { |
clear(); | 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->_isArray = true; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
|
|
void CIMValue::set(const Array<Sint32>& x) | void CIMValue::set(const Array<Sint32>& x) |
{ | { |
clear(); | 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->_isArray = true; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
|
|
void CIMValue::set(const Array<Uint64>& x) | void CIMValue::set(const Array<Uint64>& x) |
{ | { |
clear(); | 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->_isArray = true; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
|
|
void CIMValue::set(const Array<Sint64>& x) | void CIMValue::set(const Array<Sint64>& x) |
{ | { |
clear(); | 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->_isArray = true; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
|
|
void CIMValue::set(const Array<Real32>& x) | void CIMValue::set(const Array<Real32>& x) |
{ | { |
clear(); | 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->_isArray = true; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
|
|
void CIMValue::set(const Array<Real64>& x) | void CIMValue::set(const Array<Real64>& x) |
{ | { |
clear(); | 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->_isArray = true; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
|
|
void CIMValue::set(const Array<Char16>& x) | void CIMValue::set(const Array<Char16>& x) |
{ | { |
clear(); | 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->_isArray = true; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
|
|
void CIMValue::set(const Array<String>& x) | void CIMValue::set(const Array<String>& x) |
{ | { |
clear(); | 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->_isArray = true; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
|
|
void CIMValue::set(const Array<CIMDateTime>& x) | void CIMValue::set(const Array<CIMDateTime>& x) |
{ | { |
clear(); | 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<CIMObjectPath>& x) |
|
{ |
|
clear(); |
|
_rep->_u._referenceArray = new Array<CIMObjectPath>(x); |
|
_rep->_type = CIMTYPE_REFERENCE; |
_rep->_isArray = true; | _rep->_isArray = true; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
void CIMValue::set(const Array<CIMReference>& x) |
void CIMValue::set(const Array<CIMObject>& x) |
{ | { |
clear(); | clear(); |
_Inc(_rep->_u._referenceArray = x._rep); |
_rep->_u._cimobjectArray = new Array<CIMObject>(x); |
_rep->_type = CIMType::REFERENCE; |
_rep->_type = CIMTYPE_OBJECT; |
_rep->_isArray = true; | _rep->_isArray = true; |
_rep->_isNull = false; | _rep->_isNull = false; |
} | } |
| |
void CIMValue::get(Boolean& x) const | void CIMValue::get(Boolean& x) const |
{ | { |
if (_rep->_type != CIMType::BOOLEAN || _rep->_isArray) |
if (_rep->_type != CIMTYPE_BOOLEAN || _rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
|
if (!_rep->_isNull) |
x = _rep->_u._booleanValue != 0; | x = _rep->_u._booleanValue != 0; |
} | } |
| |
void CIMValue::get(Uint8& x) const | void CIMValue::get(Uint8& x) const |
{ | { |
if (_rep->_type != CIMType::UINT8 || _rep->_isArray) |
if (_rep->_type != CIMTYPE_UINT8 || _rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
|
if (!_rep->_isNull) |
x = _rep->_u._uint8Value; | x = _rep->_u._uint8Value; |
} | } |
| |
void CIMValue::get(Sint8& x) const | void CIMValue::get(Sint8& x) const |
{ | { |
if (_rep->_type != CIMType::SINT8 || _rep->_isArray) |
if (_rep->_type != CIMTYPE_SINT8 || _rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
|
if (!_rep->_isNull) |
x = _rep->_u._sint8Value; | x = _rep->_u._sint8Value; |
} | } |
| |
void CIMValue::get(Uint16& x) const | void CIMValue::get(Uint16& x) const |
{ | { |
if (_rep->_type != CIMType::UINT16 || _rep->_isArray) |
if (_rep->_type != CIMTYPE_UINT16 || _rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
|
if (!_rep->_isNull) |
x = _rep->_u._uint16Value; | x = _rep->_u._uint16Value; |
} | } |
| |
void CIMValue::get(Sint16& x) const | void CIMValue::get(Sint16& x) const |
{ | { |
if (_rep->_type != CIMType::SINT16 || _rep->_isArray) |
if (_rep->_type != CIMTYPE_SINT16 || _rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
|
if (!_rep->_isNull) |
x = _rep->_u._sint16Value; | x = _rep->_u._sint16Value; |
} | } |
| |
void CIMValue::get(Uint32& x) const | void CIMValue::get(Uint32& x) const |
{ | { |
if (_rep->_type != CIMType::UINT32 || _rep->_isArray) |
if (_rep->_type != CIMTYPE_UINT32 || _rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
|
if (!_rep->_isNull) |
x = _rep->_u._uint32Value; | x = _rep->_u._uint32Value; |
} | } |
| |
void CIMValue::get(Sint32& x) const | void CIMValue::get(Sint32& x) const |
{ | { |
if (_rep->_type != CIMType::SINT32 || _rep->_isArray) |
if (_rep->_type != CIMTYPE_SINT32 || _rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
|
if (!_rep->_isNull) |
x = _rep->_u._sint32Value; | x = _rep->_u._sint32Value; |
} | } |
| |
void CIMValue::get(Uint64& x) const | void CIMValue::get(Uint64& x) const |
{ | { |
if (_rep->_type != CIMType::UINT64 || _rep->_isArray) |
if (_rep->_type != CIMTYPE_UINT64 || _rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
|
if (!_rep->_isNull) |
x = _rep->_u._uint64Value; | x = _rep->_u._uint64Value; |
} | } |
| |
void CIMValue::get(Sint64& x) const | void CIMValue::get(Sint64& x) const |
{ | { |
if (_rep->_type != CIMType::SINT64 || _rep->_isArray) |
if (_rep->_type != CIMTYPE_SINT64 || _rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
|
if (!_rep->_isNull) |
x = _rep->_u._sint64Value; | x = _rep->_u._sint64Value; |
} | } |
| |
void CIMValue::get(Real32& x) const | void CIMValue::get(Real32& x) const |
{ | { |
if (_rep->_type != CIMType::REAL32 || _rep->_isArray) |
if (_rep->_type != CIMTYPE_REAL32 || _rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
|
if (!_rep->_isNull) |
x = _rep->_u._real32Value; | x = _rep->_u._real32Value; |
} | } |
| |
void CIMValue::get(Real64& x) const | void CIMValue::get(Real64& x) const |
{ | { |
if (_rep->_type != CIMType::REAL64 || _rep->_isArray) |
if (_rep->_type != CIMTYPE_REAL64 || _rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
|
if (!_rep->_isNull) |
x = _rep->_u._real64Value; | x = _rep->_u._real64Value; |
} | } |
| |
void CIMValue::get(Char16& x) const | void CIMValue::get(Char16& x) const |
{ | { |
if (_rep->_type != CIMType::CHAR16 || _rep->_isArray) |
if (_rep->_type != CIMTYPE_CHAR16 || _rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
|
if (!_rep->_isNull) |
x = _rep->_u._char16Value; | x = _rep->_u._char16Value; |
} | } |
| |
void CIMValue::get(String& x) const | void CIMValue::get(String& x) const |
{ | { |
if (_rep->_type != CIMType::STRING || _rep->_isArray) |
if (_rep->_type != CIMTYPE_STRING || _rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
|
if (!_rep->_isNull) |
x = *_rep->_u._stringValue; | x = *_rep->_u._stringValue; |
} | } |
| |
void CIMValue::get(CIMDateTime& x) const | void CIMValue::get(CIMDateTime& x) const |
{ | { |
if (_rep->_type != CIMType::DATETIME || _rep->_isArray) |
if (_rep->_type != CIMTYPE_DATETIME || _rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
|
if (!_rep->_isNull) |
x = *_rep->_u._dateTimeValue; | 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(); |
throw TypeMismatchException(); |
| |
|
if (!_rep->_isNull) |
x = *_rep->_u._referenceValue; | 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._cimobjectValue; |
|
} |
|
|
void CIMValue::get(Array<Boolean>& x) const | void CIMValue::get(Array<Boolean>& x) const |
{ | { |
if (_rep->_type != CIMType::BOOLEAN || !_rep->_isArray) |
if (_rep->_type != CIMTYPE_BOOLEAN || !_rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_rep->_u._booleanArray); |
if (!_rep->_isNull) |
|
x = *_rep->_u._booleanArray; |
} | } |
| |
void CIMValue::get(Array<Uint8>& x) const | void CIMValue::get(Array<Uint8>& x) const |
{ | { |
if (_rep->_type != CIMType::UINT8 || !_rep->_isArray) |
if (_rep->_type != CIMTYPE_UINT8 || !_rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_rep->_u._uint8Array); |
if (!_rep->_isNull) |
|
x = *_rep->_u._uint8Array; |
} | } |
| |
void CIMValue::get(Array<Sint8>& x) const | void CIMValue::get(Array<Sint8>& x) const |
{ | { |
if (_rep->_type != CIMType::SINT8 || !_rep->_isArray) |
if (_rep->_type != CIMTYPE_SINT8 || !_rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_rep->_u._sint8Array); |
if (!_rep->_isNull) |
|
x = *_rep->_u._sint8Array; |
} | } |
| |
void CIMValue::get(Array<Uint16>& x) const | void CIMValue::get(Array<Uint16>& x) const |
{ | { |
if (_rep->_type != CIMType::UINT16 || !_rep->_isArray) |
if (_rep->_type != CIMTYPE_UINT16 || !_rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_rep->_u._uint16Array); |
if (!_rep->_isNull) |
|
x = *_rep->_u._uint16Array; |
} | } |
| |
void CIMValue::get(Array<Sint16>& x) const | void CIMValue::get(Array<Sint16>& x) const |
{ | { |
if (_rep->_type != CIMType::SINT16 || !_rep->_isArray) |
if (_rep->_type != CIMTYPE_SINT16 || !_rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_rep->_u._sint16Array); |
if (!_rep->_isNull) |
|
x = *_rep->_u._sint16Array; |
} | } |
| |
void CIMValue::get(Array<Uint32>& x) const | void CIMValue::get(Array<Uint32>& x) const |
{ | { |
if (_rep->_type != CIMType::UINT32 || !_rep->_isArray) |
if (_rep->_type != CIMTYPE_UINT32 || !_rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_rep->_u._uint32Array); |
if (!_rep->_isNull) |
|
x = *_rep->_u._uint32Array; |
} | } |
| |
void CIMValue::get(Array<Sint32>& x) const | void CIMValue::get(Array<Sint32>& x) const |
{ | { |
if (_rep->_type != CIMType::SINT32 || !_rep->_isArray) |
if (_rep->_type != CIMTYPE_SINT32 || !_rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_rep->_u._sint32Array); |
if (!_rep->_isNull) |
|
x = *_rep->_u._sint32Array; |
} | } |
| |
void CIMValue::get(Array<Uint64>& x) const | void CIMValue::get(Array<Uint64>& x) const |
{ | { |
if (_rep->_type != CIMType::UINT64 || !_rep->_isArray) |
if (_rep->_type != CIMTYPE_UINT64 || !_rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_rep->_u._uint64Array); |
if (!_rep->_isNull) |
|
x = *_rep->_u._uint64Array; |
} | } |
| |
void CIMValue::get(Array<Sint64>& x) const | void CIMValue::get(Array<Sint64>& x) const |
{ | { |
if (_rep->_type != CIMType::SINT64 || !_rep->_isArray) |
if (_rep->_type != CIMTYPE_SINT64 || !_rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_rep->_u._sint64Array); |
if (!_rep->_isNull) |
|
x = *_rep->_u._sint64Array; |
} | } |
| |
void CIMValue::get(Array<Real32>& x) const | void CIMValue::get(Array<Real32>& x) const |
{ | { |
if (_rep->_type != CIMType::REAL32 || !_rep->_isArray) |
if (_rep->_type != CIMTYPE_REAL32 || !_rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_rep->_u._real32Array); |
if (!_rep->_isNull) |
|
x = *_rep->_u._real32Array; |
} | } |
| |
void CIMValue::get(Array<Real64>& x) const | void CIMValue::get(Array<Real64>& x) const |
{ | { |
if (_rep->_type != CIMType::REAL64 || !_rep->_isArray) |
if (_rep->_type != CIMTYPE_REAL64 || !_rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_rep->_u._real64Array); |
if (!_rep->_isNull) |
|
x = *_rep->_u._real64Array; |
} | } |
| |
void CIMValue::get(Array<Char16>& x) const | void CIMValue::get(Array<Char16>& x) const |
{ | { |
if (_rep->_type != CIMType::CHAR16 || !_rep->_isArray) |
if (_rep->_type != CIMTYPE_CHAR16 || !_rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_rep->_u._char16Array); |
if (!_rep->_isNull) |
|
x = *_rep->_u._char16Array; |
} | } |
| |
void CIMValue::get(Array<String>& x) const | void CIMValue::get(Array<String>& x) const |
{ | { |
if (_rep->_type != CIMType::STRING || !_rep->_isArray) |
if (_rep->_type != CIMTYPE_STRING || !_rep->_isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_rep->_u._stringArray); |
if (!_rep->_isNull) |
|
x = *_rep->_u._stringArray; |
} | } |
| |
void CIMValue::get(Array<CIMDateTime>& x) const | void CIMValue::get(Array<CIMDateTime>& x) const |
{ | { |
#ifdef CIMValueisNullexception |
if (_rep->_type != CIMTYPE_DATETIME || !_rep->_isArray) |
if (_rep->_isNull) |
throw TypeMismatchException(); |
throw CIMValueIsNull(); |
|
#endif |
|
|
|
if (_rep->_type != CIMType::DATETIME || !_rep->_isArray) |
|
throw TypeMismatch(); |
|
| |
x.set(_rep->_u._dateTimeArray); |
if (!_rep->_isNull) |
|
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(); |
throw TypeMismatchException(); |
| |
x.set(_rep->_u._referenceArray); |
if (!_rep->_isNull) |
|
x = *_rep->_u._referenceArray; |
} | } |
| |
void CIMValue::toXml(Array<Sint8>& out) const |
void CIMValue::get(Array<CIMObject>& x) const |
{ | { |
/* If the CIMValue is Null, no element is returned. |
if (_rep->_type != CIMTYPE_OBJECT || !_rep->_isArray) |
Note that it output absolutely nothing. This works for |
throw TypeMismatchException(); |
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->_u._cimobjectArray; |
if (_rep->_isNull) |
|
{ |
|
return; |
|
} | } |
if (_rep->_isArray) |
|
{ |
|
switch (_rep->_type) |
|
{ |
|
case CIMType::BOOLEAN: |
|
{ |
|
_toXml(out, _rep->_u._booleanArray->data(), |
|
_rep->_u._booleanArray->size); |
|
// ATTN-RK-P3-20020220: Is there a reason to do it this way? |
|
//out << "<VALUE.ARRAY>\n"; |
|
//for (Uint32 i=0, n = _rep->_u._booleanArray->size; i<n; i++) |
|
//{ |
|
// out << "<VALUE>"; |
|
// _toXml(out, Boolean(_rep->_u._booleanArray->data()[i])); |
|
// out << "</VALUE>\n"; |
|
//} |
|
//out << "</VALUE.ARRAY>\n"; |
|
break; |
|
} |
|
|
|
case CIMType::UINT8: |
|
_toXml(out, _rep->_u._uint8Array->data(), |
|
_rep->_u._uint8Array->size); |
|
break; |
|
| |
case CIMType::SINT8: |
Boolean CIMValue::equal(const CIMValue& x) const |
_toXml(out, _rep->_u._sint8Array->data(), |
|
_rep->_u._sint8Array->size); |
|
break; |
|
|
|
case CIMType::UINT16: |
|
_toXml(out, _rep->_u._uint16Array->data(), |
|
_rep->_u._uint16Array->size); |
|
break; |
|
|
|
case CIMType::SINT16: |
|
_toXml(out, _rep->_u._sint16Array->data(), |
|
_rep->_u._sint16Array->size); |
|
break; |
|
|
|
case CIMType::UINT32: |
|
_toXml(out, _rep->_u._uint32Array->data(), |
|
_rep->_u._uint32Array->size); |
|
break; |
|
|
|
case CIMType::SINT32: |
|
_toXml(out, _rep->_u._sint32Array->data(), |
|
_rep->_u._sint32Array->size); |
|
break; |
|
|
|
case CIMType::UINT64: |
|
_toXml(out, _rep->_u._uint64Array->data(), |
|
_rep->_u._uint64Array->size); |
|
break; |
|
|
|
case CIMType::SINT64: |
|
_toXml(out, _rep->_u._sint64Array->data(), |
|
_rep->_u._sint64Array->size); |
|
break; |
|
|
|
case CIMType::REAL32: |
|
_toXml(out, _rep->_u._real32Array->data(), |
|
_rep->_u._real32Array->size); |
|
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: |
if (!typeCompatible(x)) |
_toXml(out, Boolean(_rep->_u._booleanValue != 0)); |
return false; |
break; |
|
|
|
case CIMType::UINT8: |
|
_toXml(out, _rep->_u._uint8Value); |
|
break; |
|
|
|
case CIMType::SINT8: |
|
_toXml(out, _rep->_u._sint8Value); |
|
break; |
|
|
|
case CIMType::UINT16: |
|
_toXml(out, _rep->_u._uint16Value); |
|
break; |
|
|
|
case CIMType::SINT16: |
|
_toXml(out, _rep->_u._sint16Value); |
|
break; |
|
|
|
case CIMType::UINT32: |
|
_toXml(out, _rep->_u._uint32Value); |
|
break; |
|
|
|
case CIMType::SINT32: |
|
_toXml(out, _rep->_u._sint32Value); |
|
break; |
|
|
|
case CIMType::UINT64: |
|
_toXml(out, _rep->_u._uint64Value); |
|
break; |
|
|
|
case CIMType::SINT64: |
|
_toXml(out, _rep->_u._sint64Value); |
|
break; |
|
|
|
case CIMType::REAL32: |
|
_toXml(out, _rep->_u._real32Value); |
|
break; |
|
|
|
case CIMType::REAL64: |
|
_toXml(out, _rep->_u._real64Value); |
|
break; |
|
|
|
case CIMType::CHAR16: |
|
_toXml(out, Char16(_rep->_u._char16Value)); |
|
break; |
|
|
|
case CIMType::STRING: |
|
_toXml(out, *_rep->_u._stringValue); |
|
break; |
|
|
|
case CIMType::DATETIME: |
|
_toXml(out, *_rep->_u._dateTimeValue); |
|
break; |
|
default: |
|
throw CIMValueInvalidType(); |
|
} |
|
|
|
out << "</VALUE>\n"; |
|
} |
|
} |
|
|
|
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->_isNull != x._rep->_isNull) |
|
return false; |
| |
if (_rep->_isArray) | if (_rep->_isArray) |
{ | { |
switch (_rep->_type) | switch (_rep->_type) |
{ | { |
case CIMType::BOOLEAN: |
case CIMTYPE_BOOLEAN: |
{ |
return (*_rep->_u._booleanArray) == |
_toMof(out, _rep->_u._booleanArray->data(), |
(*x._rep->_u._booleanArray); |
_rep->_u._booleanArray->size); |
|
break; |
case CIMTYPE_UINT8: |
} |
return (*_rep->_u._uint8Array) == |
case CIMType::UINT8: |
(*x._rep->_u._uint8Array); |
_toMof(out, _rep->_u._uint8Array->data(), |
|
_rep->_u._uint8Array->size); |
case CIMTYPE_SINT8: |
break; |
return (*_rep->_u._sint8Array) == |
|
(*x._rep->_u._sint8Array); |
case CIMType::SINT8: |
|
_toMof(out, _rep->_u._sint8Array->data(), |
case CIMTYPE_UINT16: |
_rep->_u._sint8Array->size); |
return (*_rep->_u._uint16Array) == |
break; |
(*x._rep->_u._uint16Array); |
|
|
case CIMType::UINT16: |
case CIMTYPE_SINT16: |
_toMof(out, _rep->_u._uint16Array->data(), |
return (*_rep->_u._sint16Array) == |
_rep->_u._uint16Array->size); |
(*x._rep->_u._sint16Array); |
break; |
|
|
case CIMTYPE_UINT32: |
case CIMType::SINT16: |
return (*_rep->_u._uint32Array) == |
_toMof(out, _rep->_u._sint16Array->data(), |
(*x._rep->_u._uint32Array); |
_rep->_u._sint16Array->size); |
|
break; |
case CIMTYPE_SINT32: |
|
return (*_rep->_u._sint32Array) == |
case CIMType::UINT32: |
(*x._rep->_u._sint32Array); |
_toMof(out, _rep->_u._uint32Array->data(), |
|
_rep->_u._uint32Array->size); |
case CIMTYPE_UINT64: |
break; |
return (*_rep->_u._uint64Array) == |
|
(*x._rep->_u._uint64Array); |
case CIMType::SINT32: |
|
_toMof(out, _rep->_u._sint32Array->data(), |
case CIMTYPE_SINT64: |
_rep->_u._sint32Array->size); |
return (*_rep->_u._sint64Array) == |
break; |
(*x._rep->_u._sint64Array); |
|
|
case CIMType::UINT64: |
case CIMTYPE_REAL32: |
_toMof(out, _rep->_u._uint64Array->data(), |
return (*_rep->_u._real32Array) == |
_rep->_u._uint64Array->size); |
(*x._rep->_u._real32Array); |
break; |
|
|
case CIMTYPE_REAL64: |
case CIMType::SINT64: |
return (*_rep->_u._real64Array) == |
_toMof(out, _rep->_u._sint64Array->data(), |
(*x._rep->_u._real64Array); |
_rep->_u._sint64Array->size); |
|
break; |
case CIMTYPE_CHAR16: |
|
return (*_rep->_u._char16Array) == |
case CIMType::REAL32: |
(*x._rep->_u._char16Array); |
_toMof(out, _rep->_u._real32Array->data(), |
|
_rep->_u._real32Array->size); |
case CIMTYPE_STRING: |
break; |
return (*_rep->_u._stringArray) == |
|
(*x._rep->_u._stringArray); |
case CIMType::REAL64: |
|
_toMof(out, _rep->_u._real64Array->data(), |
case CIMTYPE_DATETIME: |
_rep->_u._real64Array->size); |
return (*_rep->_u._dateTimeArray) == |
break; |
(*x._rep->_u._dateTimeArray); |
|
|
case CIMType::CHAR16: |
case CIMTYPE_REFERENCE: |
_toMof(out, _rep->_u._char16Array->data(), |
return (*_rep->_u._referenceArray) == |
_rep->_u._char16Array->size); |
(*x._rep->_u._referenceArray); |
break; |
|
|
case CIMTYPE_OBJECT: |
case CIMType::STRING: |
return (*_rep->_u._cimobjectArray) == |
_toMof(out, _rep->_u._stringArray->data(), |
(*x._rep->_u._cimobjectArray); |
_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: | default: |
throw CIMValueInvalidType(); |
PEGASUS_ASSERT(false); |
} | } |
} | } |
else | else |
{ | { |
switch (_rep->_type) | switch (_rep->_type) |
{ | { |
case CIMType::BOOLEAN: |
case CIMTYPE_BOOLEAN: |
_toMof(out, Boolean(_rep->_u._booleanValue != 0)); |
return _rep->_u._booleanValue == x._rep->_u._booleanValue; |
break; |
|
| |
case CIMType::UINT8: |
case CIMTYPE_UINT8: |
_toMof(out, _rep->_u._uint8Value); |
return _rep->_u._uint8Value == x._rep->_u._uint8Value; |
break; |
|
| |
case CIMType::SINT8: |
case CIMTYPE_SINT8: |
_toMof(out, _rep->_u._sint8Value); |
return _rep->_u._sint8Value == x._rep->_u._sint8Value; |
break; |
|
| |
case CIMType::UINT16: |
case CIMTYPE_UINT16: |
_toMof(out, _rep->_u._uint16Value); |
return _rep->_u._uint16Value == x._rep->_u._uint16Value; |
break; |
|
| |
case CIMType::SINT16: |
case CIMTYPE_SINT16: |
_toMof(out, _rep->_u._sint16Value); |
return _rep->_u._sint16Value == x._rep->_u._sint16Value; |
break; |
|
| |
case CIMType::UINT32: |
case CIMTYPE_UINT32: |
_toMof(out, _rep->_u._uint32Value); |
return _rep->_u._uint32Value == x._rep->_u._uint32Value; |
break; |
|
| |
case CIMType::SINT32: |
case CIMTYPE_SINT32: |
_toMof(out, _rep->_u._sint32Value); |
return _rep->_u._sint32Value == x._rep->_u._sint32Value; |
break; |
|
| |
case CIMType::UINT64: |
case CIMTYPE_UINT64: |
_toMof(out, _rep->_u._uint64Value); |
return _rep->_u._uint64Value == x._rep->_u._uint64Value; |
break; |
|
| |
case CIMType::SINT64: |
case CIMTYPE_SINT64: |
_toMof(out, _rep->_u._sint64Value); |
return _rep->_u._sint64Value == x._rep->_u._sint64Value; |
break; |
|
| |
case CIMType::REAL32: |
case CIMTYPE_REAL32: |
_toMof(out, _rep->_u._real32Value); |
return _rep->_u._real32Value == x._rep->_u._real32Value; |
break; |
|
| |
case CIMType::REAL64: |
case CIMTYPE_REAL64: |
_toMof(out, _rep->_u._real64Value); |
return _rep->_u._real64Value == x._rep->_u._real64Value; |
break; |
|
| |
case CIMType::CHAR16: |
case CIMTYPE_CHAR16: |
_toMof(out, Char16(_rep->_u._char16Value)); |
return _rep->_u._char16Value == x._rep->_u._char16Value; |
break; |
|
| |
case CIMType::STRING: |
case CIMTYPE_STRING: |
_toMof(out, *_rep->_u._stringValue); |
return String::equal(*_rep->_u._stringValue, |
break; |
*x._rep->_u._stringValue); |
| |
case CIMType::DATETIME: |
case CIMTYPE_DATETIME: |
_toMof(out, *_rep->_u._dateTimeValue); |
return *_rep->_u._dateTimeValue == *x._rep->_u._dateTimeValue; |
break; |
|
| |
case CIMType::REFERENCE: |
case CIMTYPE_REFERENCE: |
_toMof(out, *_rep->_u._referenceValue); |
return *_rep->_u._referenceValue == |
break; |
*x._rep->_u._referenceValue; |
|
|
|
case CIMTYPE_OBJECT: |
|
return (*_rep->_u._cimobjectValue).identical((*x._rep->_u._cimobjectValue)); |
| |
default: | default: |
throw CIMValueInvalidType(); |
PEGASUS_ASSERT(false); |
} | } |
} | } |
|
|
|
// Unreachable! |
|
return false; |
} | } |
| |
String CIMValue::toString() const | String CIMValue::toString() const |
|
|
{ | { |
switch (_rep->_type) | 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++) | for (Uint32 i = 0; i < size; i++) |
{ | { |
_toString(out, Boolean(_rep->_u._booleanArray->data()[i])); |
_toString(out, Boolean(_rep->_u._booleanArray->getData()[i])); |
out << " "; | out << " "; |
} | } |
break; | 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; | 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; | 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; | 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; | 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; | 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; | 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; | 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; | 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; | 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; | 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; | 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; | 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; | 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; |
|
|
|
case CIMTYPE_OBJECT: |
|
_toString(out, _rep->_u._cimobjectArray->getData(), |
|
_rep->_u._cimobjectArray->size()); |
break; | break; |
| |
default: | default: |
throw CIMValueInvalidType(); |
PEGASUS_ASSERT(false); |
} | } |
} | } |
else | else |
{ | { |
switch (_rep->_type) | switch (_rep->_type) |
{ | { |
case CIMType::BOOLEAN: |
case CIMTYPE_BOOLEAN: |
_toString(out, Boolean(_rep->_u._booleanValue != 0)); | _toString(out, Boolean(_rep->_u._booleanValue != 0)); |
break; | break; |
| |
case CIMType::UINT8: |
case CIMTYPE_UINT8: |
_toString(out, _rep->_u._uint8Value); | _toString(out, _rep->_u._uint8Value); |
break; | break; |
| |
case CIMType::SINT8: |
case CIMTYPE_SINT8: |
_toString(out, _rep->_u._sint8Value); | _toString(out, _rep->_u._sint8Value); |
break; | break; |
| |
case CIMType::UINT16: |
case CIMTYPE_UINT16: |
_toString(out, _rep->_u._uint16Value); | _toString(out, _rep->_u._uint16Value); |
break; | break; |
| |
case CIMType::SINT16: |
case CIMTYPE_SINT16: |
_toString(out, _rep->_u._sint16Value); | _toString(out, _rep->_u._sint16Value); |
break; | break; |
| |
case CIMType::UINT32: |
case CIMTYPE_UINT32: |
_toString(out, _rep->_u._uint32Value); | _toString(out, _rep->_u._uint32Value); |
break; | break; |
| |
case CIMType::SINT32: |
case CIMTYPE_SINT32: |
_toString(out, _rep->_u._sint32Value); | _toString(out, _rep->_u._sint32Value); |
break; | break; |
| |
case CIMType::UINT64: |
case CIMTYPE_UINT64: |
_toString(out, _rep->_u._uint64Value); | _toString(out, _rep->_u._uint64Value); |
break; | break; |
| |
case CIMType::SINT64: |
case CIMTYPE_SINT64: |
_toString(out, _rep->_u._sint64Value); | _toString(out, _rep->_u._sint64Value); |
break; | break; |
| |
case CIMType::REAL32: |
case CIMTYPE_REAL32: |
_toString(out, _rep->_u._real32Value); | _toString(out, _rep->_u._real32Value); |
break; | break; |
| |
case CIMType::REAL64: |
case CIMTYPE_REAL64: |
_toString(out, _rep->_u._real64Value); | _toString(out, _rep->_u._real64Value); |
break; | break; |
| |
case CIMType::CHAR16: |
case CIMTYPE_CHAR16: |
_toString(out, Char16(_rep->_u._char16Value)); | _toString(out, Char16(_rep->_u._char16Value)); |
break; | break; |
| |
case CIMType::STRING: |
case CIMTYPE_STRING: |
_toString(out, *_rep->_u._stringValue); | _toString(out, *_rep->_u._stringValue); |
break; | break; |
| |
case CIMType::DATETIME: |
case CIMTYPE_DATETIME: |
_toString(out, *_rep->_u._dateTimeValue); | _toString(out, *_rep->_u._dateTimeValue); |
break; | break; |
| |
case CIMType::REFERENCE: |
case CIMTYPE_REFERENCE: |
_toString(out, *_rep->_u._referenceValue); | _toString(out, *_rep->_u._referenceValue); |
break; | break; |
| |
|
case CIMTYPE_OBJECT: |
|
_toString(out, *_rep->_u._cimobjectValue); |
|
break; |
|
|
default: | default: |
throw CIMValueInvalidType(); |
PEGASUS_ASSERT(false); |
} | } |
} | } |
| |
|
|
| |
Boolean operator==(const CIMValue& x, const CIMValue& y) | 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) | Boolean operator!=(const CIMValue& x, const CIMValue& y) |
{ | { |
return !operator==(x, y); |
return !x.equal(y); |
} | } |
| |
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |