version 1.2, 2001/02/26 04:33:28
|
version 1.75, 2008/12/02 09:00:46
|
|
|
//BEGIN_LICENSE |
//%LICENSE//////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM |
// Licensed to The Open Group (TOG) under one or more contributor license |
|
// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with |
|
// this work for additional information regarding copyright ownership. |
|
// Each contributor licenses this file to you under the OpenPegasus Open |
|
// Source License; you may not use this file except in compliance with the |
|
// License. |
// | // |
// Permission is hereby granted, free of charge, to any person obtaining a | // Permission is hereby granted, free of charge, to any person obtaining a |
// copy of this software and associated documentation files (the "Software"), | // copy of this software and associated documentation files (the "Software"), |
|
|
// and/or sell copies of the Software, and to permit persons to whom the | // and/or sell copies of the Software, and to permit persons to whom the |
// Software is furnished to do so, subject to the following conditions: | // Software is furnished to do so, subject to the following conditions: |
// | // |
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
// The above copyright notice and this permission notice shall be included |
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
// in all copies or substantial portions of the Software. |
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
|
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|
// DEALINGS IN THE SOFTWARE. |
|
// | // |
//END_LICENSE |
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
//BEGIN_HISTORY |
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
|
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
|
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
|
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
|
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
// | // |
// Author: |
////////////////////////////////////////////////////////////////////////// |
// | // |
// $Log$ |
//%///////////////////////////////////////////////////////////////////////////// |
// Revision 1.2 2001/02/26 04:33:28 mike |
|
// Fixed many places where cim names were be compared with operator==(String,String). |
|
// Changed all of these to use CIMName::equal() |
|
// |
|
// Revision 1.1 2001/02/18 18:39:06 mike |
|
// new |
|
// |
|
// Revision 1.1 2001/02/16 02:07:06 mike |
|
// Renamed many classes and headers (using new CIM prefixes). |
|
// |
|
// Revision 1.1.1.1 2001/01/14 19:53:20 mike |
|
// Pegasus import |
|
// |
|
// |
|
//END_HISTORY |
|
| |
#include <cstring> | #include <cstring> |
#include <cstdio> | #include <cstdio> |
#include <cassert> |
|
#include <cctype> | #include <cctype> |
#include "CIMValue.h" | #include "CIMValue.h" |
#include "Indentor.h" |
#include "CIMInstance.h" |
#include "Exception.h" |
#include "Union.h" |
#include "XmlWriter.h" | #include "XmlWriter.h" |
|
#include "CommonUTF.h" |
|
#include "CIMValueRep.h" |
|
#include "Config.h" |
|
#include "CIMType.h" |
|
#include "String.h" |
|
#include "CIMDateTime.h" |
|
#include "CIMObjectPath.h" |
|
#include "CIMObject.h" |
|
#include "Array.h" |
|
#include <Pegasus/Common/PegasusAssert.h> |
| |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
template<class T> |
#define PEGASUS_ARRAY_T CIMValue |
inline void _Inc(ArrayRep<T>* rep) |
# include "ArrayImpl.h" |
{ |
#undef PEGASUS_ARRAY_T |
ArrayRep<T>::inc(rep); |
|
} |
|
| |
template<class T> |
// ATTN: By getting a CIMObject from a CIMValue, the client of CIMValue can |
inline void _Dec(ArrayRep<T>* rep) |
// modify the internals of that CIMObject and thus change what CIMValue |
{ |
// itself refers to. There are two solutions: clone() at ever juncture or |
ArrayRep<T>::dec(rep); |
// force CIMValue to make its own unique copy when the client calls get() |
} |
// to get a CIMObject. |
| |
//////////////////////////////////////////////////////////////////////////////// |
//============================================================================== |
// | // |
// Local helper functions: |
// _toString() routines: |
// | // |
//////////////////////////////////////////////////////////////////////////////// |
//============================================================================== |
| |
//------------------------------------------------------------------------------ |
inline void _toString(Buffer& out, Boolean x) |
// |
|
// _SignedIntToStr() |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
static void _SignedIntToStr(Sint64 x, char* result) |
|
{ | { |
if (!result) |
XmlWriter::append(out, x); |
return; |
|
|
|
if (x == 0) |
|
{ |
|
result[0] = '0'; |
|
result[1] = '\0'; |
|
return; |
|
} | } |
| |
char buffer[256]; |
inline void _toString(Buffer& out, Uint8 x) |
Uint32 len = 0; |
|
Boolean negative = false; |
|
|
|
for (Uint32 i = 0; 1; i++) |
|
{ | { |
Sint64 q = x / 10; |
XmlWriter::append(out, Uint32(x)); |
Sint32 r = x % 10; |
} |
|
|
if (q == 0 && r == 0) |
|
break; |
|
| |
if (r < 0) |
inline void _toString(Buffer& out, Sint8 x) |
{ | { |
r = -r; |
XmlWriter::append(out, Sint32(x)); |
negative = true; |
|
} | } |
| |
buffer[len++] = r + '0'; |
inline void _toString(Buffer& out, Uint16 x) |
|
{ |
x = q ; |
XmlWriter::append(out, Uint32(x)); |
} | } |
| |
buffer[len] = '\0'; |
inline void _toString(Buffer& out, Sint16 x) |
|
{ |
// If buffer was negative, prepend sign: |
XmlWriter::append(out, Sint32(x)); |
|
|
char* q = result; |
|
|
|
if (negative) |
|
*q++ = '-'; |
|
|
|
// Reverse the buffer: |
|
|
|
char* p = &buffer[len]; |
|
|
|
while (len--) |
|
*q++ = *--p; |
|
|
|
*q++ = '\0'; |
|
} | } |
| |
//------------------------------------------------------------------------------ |
inline void _toString(Buffer& out, Uint32 x) |
// |
|
// _UnsignedIntToStr() |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
static void _UnsignedIntToStr(Uint64 x, char* result) |
|
{ | { |
if (!result) |
XmlWriter::append(out, x); |
return; |
} |
| |
if (x == 0) |
inline void _toString(Buffer& out, Sint32 x) |
{ | { |
result[0] = '0'; |
XmlWriter::append(out, x); |
result[1] = '\0'; |
|
return; |
|
} | } |
| |
char buffer[256]; |
inline void _toString(Buffer& out, Uint64 x) |
Uint32 len = 0; |
|
Boolean negative = false; |
|
|
|
for (Uint32 i = 0; 1; i++) |
|
{ | { |
Sint64 q = x / 10; |
XmlWriter::append(out, x); |
Sint32 r = x % 10; |
|
|
|
if (q == 0 && r == 0) |
|
break; |
|
|
|
buffer[len++] = r + '0'; |
|
|
|
x = q ; |
|
} | } |
| |
buffer[len] = '\0'; |
inline void _toString(Buffer& out, Sint64 x) |
|
{ |
// Reverse the buffer onto output: |
XmlWriter::append(out, x); |
|
|
char* q = result; |
|
|
|
char* p = &buffer[len]; |
|
|
|
while (len--) |
|
*q++ = *--p; |
|
|
|
*q++ = '\0'; |
|
} | } |
| |
//------------------------------------------------------------------------------ |
inline void _toString(Buffer& out, Real32 x) |
// |
|
// _toXml() routines: |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
inline void _toXml(Array<Sint8>& out, Boolean x) |
|
{ | { |
out << (x ? "TRUE" : "FALSE"); |
XmlWriter::append(out, Real64(x)); |
} | } |
| |
template<class T> |
inline void _toString(Buffer& out, Real64 x) |
inline void _integerToXml(Array<Sint8>& out, const T& x) |
|
{ | { |
char buffer[32]; |
XmlWriter::append(out, x); |
sprintf(buffer, "%d", x); |
|
out << (char*)buffer; |
|
} | } |
| |
inline void _toXml(Array<Sint8>& out, Uint8 x) { _integerToXml(out, x); } |
inline void _toString(Buffer& out, Char16 x) |
|
{ |
inline void _toXml(Array<Sint8>& out, Sint8 x) { _integerToXml(out, x); } |
// We need to convert the Char16 to UTF8 then append the UTF8 |
|
// character into the array. |
inline void _toXml(Array<Sint8>& out, Uint16 x) { _integerToXml(out, x); } |
// NOTE: The UTF8 character could be several bytes long. |
|
// WARNING: This function will put in replacement character for |
|
// all characters that have surogate pairs. |
| |
inline void _toXml(Array<Sint8>& out, Sint16 x) { _integerToXml(out, x); } |
char str[6]; |
|
memset(str,0x00,sizeof(str)); |
|
char* charIN = (char *)&x; |
| |
inline void _toXml(Array<Sint8>& out, Uint32 x) { _integerToXml(out, x); } |
const Uint16 *strsrc = (Uint16 *)charIN; |
|
Uint16 *endsrc = (Uint16 *)&charIN[1]; |
| |
inline void _toXml(Array<Sint8>& out, Sint32 x) { _integerToXml(out, x); } |
Uint8 *strtgt = (Uint8 *)str; |
|
Uint8 *endtgt = (Uint8 *)&str[5]; |
| |
inline void _toXml(Array<Sint8>& out, Uint64 x) |
UTF16toUTF8(&strsrc, endsrc, &strtgt, endtgt); |
{ |
out.append(str, UTF_8_COUNT_TRAIL_BYTES(str[0]) +1); |
char buffer[128]; |
|
_UnsignedIntToStr(x, buffer); |
|
out << buffer; |
|
} | } |
| |
inline void _toXml(Array<Sint8>& out, Sint64 x) |
inline void _toString(Buffer& out, const String& x) |
{ | { |
char buffer[128]; |
out << x; |
_SignedIntToStr(x, buffer); |
|
out << buffer; |
|
} | } |
| |
void _toXml(Array<Sint8>& out, Real32 x) |
inline void _toString(Buffer& out, const CIMDateTime& x) |
{ | { |
// ATTN: Does this format match the CIM/XML format? |
out << x.toString(); |
char buffer[128]; |
|
sprintf(buffer, "%f", x); |
|
out << buffer; |
|
} | } |
| |
void _toXml(Array<Sint8>& out, Real64 x) |
inline void _toString(Buffer& out, const CIMObjectPath& x) |
{ | { |
char buffer[128]; |
out << x.toString(); |
sprintf(buffer, "%f", x); |
|
out << buffer; |
|
} | } |
| |
inline void _toXml(Array<Sint8>& out, Char16 x) |
inline void _toString(Buffer& out, const CIMObject& x) |
{ | { |
XmlWriter::appendSpecial(out, x); |
out << x.toString(); |
} | } |
|
inline void _toString(Buffer& out, const CIMInstance& x) |
inline void _toXml(Array<Sint8>& out, const String& x) |
|
{ | { |
XmlWriter::appendSpecial(out, x); |
out << CIMObject(x).toString(); |
} |
|
|
|
inline void _toXml(Array<Sint8>& out, const CIMDateTime& x) |
|
{ |
|
out << x.getString(); |
|
} | } |
| |
template<class T> | template<class T> |
void _toXml(Array<Sint8>& out, const T* p, Uint32 size) |
void _toString(Buffer& out, const T* p, Uint32 size) |
{ | { |
while (size--) | while (size--) |
{ | { |
out << "<VALUE>"; |
_toString(out, *p++); |
|
out.append(' '); |
_toXml(out, *p++); |
|
|
|
out << "</VALUE>\n"; |
|
} |
|
} |
|
|
|
template<class T> |
|
void _toStr(Array<Sint8>& out, const T* p, Uint32 size) |
|
{ |
|
while (size--) |
|
{ |
|
_toXml(out, *p++); |
|
out << " "; |
|
} | } |
} | } |
| |
//////////////////////////////////////////////////////////////////////////////// |
//============================================================================== |
// | // |
// CIMValue |
// CIMValueRep |
// | // |
//////////////////////////////////////////////////////////////////////////////// |
//============================================================================== |
| |
CIMValue::CIMValue() |
CIMValueRep CIMValueRep::_emptyRep((int*)0); |
{ |
|
_init(); |
|
} |
|
| |
CIMValue::CIMValue(const CIMValue& x) |
void CIMValueRep::release() |
{ | { |
_init(); |
if (isArray) |
assign(x); |
|
} |
|
|
|
CIMValue::~CIMValue() |
|
{ | { |
clear(); |
switch (type) |
} |
|
|
|
void CIMValue::assign(const CIMValue& x) |
|
{ | { |
if (this == &x) |
case CIMTYPE_BOOLEAN: |
return; |
CIMValueType<Boolean>::destructArray(this); |
|
break; |
clear(); |
|
| |
_type = x._type; |
case CIMTYPE_UINT8: |
_isArray = x._isArray; |
CIMValueType<Uint8>::destructArray(this); |
_u._voidPtr = 0; |
break; |
| |
if (_isArray) |
case CIMTYPE_SINT8: |
{ |
CIMValueType<Sint8>::destructArray(this); |
switch (_type) |
|
{ |
|
case CIMType::BOOLEAN: |
|
_Inc(_u._booleanArray = x._u._booleanArray); |
|
break; | break; |
| |
case CIMType::UINT8: |
case CIMTYPE_UINT16: |
_Inc(_u._uint8Array = x._u._uint8Array); |
CIMValueType<Uint16>::destructArray(this); |
break; | break; |
| |
case CIMType::SINT8: |
case CIMTYPE_SINT16: |
_Inc(_u._sint8Array = x._u._sint8Array); |
CIMValueType<Sint16>::destructArray(this); |
break; | break; |
| |
case CIMType::UINT16: |
case CIMTYPE_UINT32: |
_Inc(_u._uint16Array = x._u._uint16Array); |
CIMValueType<Uint32>::destructArray(this); |
break; | break; |
| |
case CIMType::SINT16: |
case CIMTYPE_SINT32: |
_Inc(_u._sint16Array = x._u._sint16Array); |
CIMValueType<Sint32>::destructArray(this); |
break; | break; |
| |
case CIMType::UINT32: |
case CIMTYPE_UINT64: |
_Inc(_u._uint32Array = x._u._uint32Array); |
CIMValueType<Uint64>::destructArray(this); |
break; | break; |
| |
case CIMType::SINT32: |
case CIMTYPE_SINT64: |
_Inc(_u._sint32Array = x._u._sint32Array); |
CIMValueType<Sint64>::destructArray(this); |
break; | break; |
| |
case CIMType::UINT64: |
case CIMTYPE_REAL32: |
_Inc(_u._uint64Array = x._u._uint64Array); |
CIMValueType<Real32>::destructArray(this); |
break; | break; |
| |
case CIMType::SINT64: |
case CIMTYPE_REAL64: |
_Inc(_u._sint64Array = x._u._sint64Array); |
CIMValueType<Real64>::destructArray(this); |
break; | break; |
| |
case CIMType::REAL32: |
case CIMTYPE_CHAR16: |
_Inc(_u._real32Array = x._u._real32Array); |
CIMValueType<Char16>::destructArray(this); |
break; | break; |
| |
case CIMType::REAL64: |
case CIMTYPE_STRING: |
_Inc(_u._real64Array = x._u._real64Array); |
CIMValueType<String>::destructArray(this); |
break; | break; |
| |
case CIMType::CHAR16: |
case CIMTYPE_DATETIME: |
_Inc(_u._char16Array = x._u._char16Array); |
CIMValueType<CIMDateTime>::destructArray(this); |
break; | break; |
| |
case CIMType::STRING: |
case CIMTYPE_REFERENCE: |
_Inc(_u._stringArray = x._u._stringArray); |
CIMValueType<CIMObjectPath>::destructArray(this); |
break; | break; |
| |
case CIMType::DATETIME: |
case CIMTYPE_OBJECT: |
_Inc(_u._dateTimeArray = x._u._dateTimeArray); |
CIMValueType<CIMObject>::destructArray(this); |
|
break; |
|
case CIMTYPE_INSTANCE: |
|
CIMValueType<CIMInstance>::destructArray(this); |
break; | break; |
} | } |
} | } |
else | else |
{ | { |
switch (_type) |
switch (type) |
{ | { |
case CIMType::NONE: |
case CIMTYPE_BOOLEAN: |
|
case CIMTYPE_UINT8: |
|
case CIMTYPE_SINT8: |
|
case CIMTYPE_UINT16: |
|
case CIMTYPE_SINT16: |
|
case CIMTYPE_UINT32: |
|
case CIMTYPE_SINT32: |
|
case CIMTYPE_UINT64: |
|
case CIMTYPE_SINT64: |
|
case CIMTYPE_REAL32: |
|
case CIMTYPE_REAL64: |
|
case CIMTYPE_CHAR16: |
break; | break; |
| |
case CIMType::BOOLEAN: |
case CIMTYPE_STRING: |
_u._booleanValue = x._u._booleanValue; |
CIMValueType<String>::destruct(this); |
break; | break; |
| |
case CIMType::UINT8: |
case CIMTYPE_DATETIME: |
_u._uint8Value = x._u._uint8Value; |
CIMValueType<CIMDateTime>::destruct(this); |
break; | break; |
| |
case CIMType::SINT8: |
case CIMTYPE_REFERENCE: |
_u._sint8Value = x._u._sint8Value; |
CIMValueType<CIMObjectPath>::destruct(this); |
break; | break; |
| |
case CIMType::UINT16: |
case CIMTYPE_OBJECT: |
_u._uint16Value = x._u._uint16Value; |
CIMValueType<CIMObject>::destruct(this); |
break; | break; |
|
case CIMTYPE_INSTANCE: |
case CIMType::SINT16: |
CIMValueType<CIMInstance>::destruct(this); |
_u._sint16Value = x._u._sint16Value; |
|
break; | break; |
|
} |
|
} |
|
} |
| |
case CIMType::UINT32: |
//============================================================================== |
_u._uint32Value = x._u._uint32Value; |
// |
break; |
// CIMValue |
|
// |
|
//============================================================================== |
| |
case CIMType::SINT32: |
static inline void _release(CIMValueRep*& rep) |
_u._sint32Value = x._u._sint32Value; |
{ |
break; |
if (rep->refs.get() == 1) |
|
rep->release(); |
|
else |
|
{ |
|
CIMValueRep::unref(rep); |
|
rep = new CIMValueRep; |
|
} |
|
} |
| |
case CIMType::UINT64: |
CIMValue::CIMValue(CIMType type, Boolean isArray, Uint32 arraySize) |
_u._uint64Value = x._u._uint64Value; |
{ |
break; |
_rep = new CIMValueRep; |
| |
case CIMType::SINT64: |
switch (type) |
_u._sint64Value = x._u._sint64Value; |
{ |
|
case CIMTYPE_BOOLEAN: |
|
CIMValueType<Boolean>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::REAL32: |
case CIMTYPE_UINT8: |
_u._real32Value = x._u._real32Value; |
CIMValueType<Uint8>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::REAL64: |
case CIMTYPE_SINT8: |
_u._real64Value = x._u._real64Value; |
CIMValueType<Sint8>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::CHAR16: |
case CIMTYPE_UINT16: |
_u._char16Value = x._u._char16Value; |
CIMValueType<Uint16>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::STRING: |
case CIMTYPE_SINT16: |
_u._stringValue = new String(*(x._u._stringValue)); |
CIMValueType<Sint16>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::DATETIME: |
case CIMTYPE_UINT32: |
_u._dateTimeValue = new CIMDateTime(*(x._u._dateTimeValue)); |
CIMValueType<Uint32>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::REFERENCE: |
case CIMTYPE_SINT32: |
_u._referenceValue |
CIMValueType<Sint32>::setNull(_rep, type, isArray, arraySize); |
= new CIMReference(*(x._u._referenceValue)); |
|
break; | break; |
} |
|
} |
|
} |
|
|
|
Uint32 CIMValue::getArraySize() const |
|
{ |
|
if (!_isArray) |
|
return 0; |
|
| |
switch (_type) |
case CIMTYPE_UINT64: |
{ |
CIMValueType<Uint64>::setNull(_rep, type, isArray, arraySize); |
case CIMType::NONE: |
|
return 0; |
|
break; | break; |
| |
case CIMType::BOOLEAN: |
case CIMTYPE_SINT64: |
return _u._booleanArray->size; |
CIMValueType<Sint64>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::UINT8: |
case CIMTYPE_REAL32: |
return _u._uint8Array->size; |
CIMValueType<Real32>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::SINT8: |
case CIMTYPE_REAL64: |
return _u._sint8Array->size; |
CIMValueType<Real64>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::UINT16: |
case CIMTYPE_CHAR16: |
return _u._uint16Array->size; |
CIMValueType<Char16>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::SINT16: |
case CIMTYPE_STRING: |
return _u._sint16Array->size; |
CIMValueType<String>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::UINT32: |
case CIMTYPE_DATETIME: |
return _u._uint32Array->size; |
CIMValueType<CIMDateTime>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::SINT32: |
case CIMTYPE_REFERENCE: |
return _u._sint32Array->size; |
CIMValueType<CIMObjectPath>::setNull(_rep, type, isArray,arraySize); |
break; | break; |
| |
case CIMType::UINT64: |
case CIMTYPE_OBJECT: |
return _u._uint64Array->size; |
CIMValueType<CIMObject>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
|
case CIMTYPE_INSTANCE: |
case CIMType::SINT64: |
CIMValueType<CIMInstance>::setNull(_rep, type, isArray, arraySize); |
return _u._sint64Array->size; |
|
break; | break; |
| |
case CIMType::REAL32: |
default: |
return _u._real32Array->size; |
PEGASUS_ASSERT(0); |
break; |
} |
|
} |
| |
case CIMType::REAL64: |
CIMValue::CIMValue(Boolean x) |
return _u._real64Array->size; |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Boolean>::set(_rep, x); |
|
} |
| |
case CIMType::CHAR16: |
CIMValue::CIMValue(Uint8 x) |
return _u._char16Array->size; |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Uint8>::set(_rep, x); |
|
} |
| |
case CIMType::STRING: |
CIMValue::CIMValue(Sint8 x) |
return _u._stringArray->size; |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Sint8>::set(_rep, x); |
|
} |
| |
case CIMType::DATETIME: |
CIMValue::CIMValue(Uint16 x) |
return _u._dateTimeArray->size; |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Uint16>::set(_rep, x); |
|
} |
| |
case CIMType::REFERENCE: |
CIMValue::CIMValue(Sint16 x) |
return 0; |
{ |
|
_rep = new CIMValueRep; |
|
CIMValueType<Sint16>::set(_rep, x); |
} | } |
| |
// Unreachable! |
CIMValue::CIMValue(Uint32 x) |
return 0; |
{ |
|
_rep = new CIMValueRep; |
|
CIMValueType<Uint32>::set(_rep, x); |
} | } |
| |
void CIMValue::clear() |
CIMValue::CIMValue(Sint32 x) |
{ | { |
if (_isArray) |
_rep = new CIMValueRep; |
|
CIMValueType<Sint32>::set(_rep, x); |
|
} |
|
|
|
CIMValue::CIMValue(Uint64 x) |
{ | { |
switch (_type) |
_rep = new CIMValueRep; |
|
CIMValueType<Uint64>::set(_rep, x); |
|
} |
|
|
|
CIMValue::CIMValue(Sint64 x) |
{ | { |
case CIMType::BOOLEAN: |
_rep = new CIMValueRep; |
_Dec(_u._booleanArray); |
CIMValueType<Sint64>::set(_rep, x); |
break; |
} |
| |
case CIMType::UINT8: |
CIMValue::CIMValue(Real32 x) |
_Dec(_u._uint8Array); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Real32>::set(_rep, x); |
|
} |
| |
case CIMType::SINT8: |
CIMValue::CIMValue(Real64 x) |
_Dec(_u._sint8Array); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Real64>::set(_rep, x); |
|
} |
| |
case CIMType::UINT16: |
CIMValue::CIMValue(const Char16& x) |
_Dec(_u._uint16Array); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Char16>::set(_rep, x); |
|
} |
| |
case CIMType::SINT16: |
CIMValue::CIMValue(const String& x) |
_Dec(_u._sint16Array); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<String>::set(_rep, x); |
|
} |
| |
case CIMType::UINT32: |
CIMValue::CIMValue(const CIMDateTime& x) |
_Dec(_u._uint32Array); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<CIMDateTime>::set(_rep, x); |
|
} |
| |
case CIMType::SINT32: |
CIMValue::CIMValue(const CIMObjectPath& x) |
_Dec(_u._sint32Array); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<CIMObjectPath>::set(_rep, x); |
|
} |
| |
case CIMType::UINT64: |
CIMValue::CIMValue(const CIMObject& x) |
_Dec(_u._uint64Array); |
{ |
break; |
if (x.isUninitialized()) |
|
{ |
|
// Bug 3373, throw exception if uninitialized object is passed to set(). |
|
throw UninitializedObjectException(); |
|
} |
| |
case CIMType::SINT64: |
_rep = new CIMValueRep; |
_Dec(_u._sint64Array); |
CIMValueType<CIMObject>::set(_rep, x.clone()); |
break; |
} |
|
CIMValue::CIMValue(const CIMInstance& x) |
|
{ |
|
if (x.isUninitialized()) |
|
{ |
|
// Bug 3373, throw exception if uninitialized object is passed to set(). |
|
throw UninitializedObjectException(); |
|
} |
| |
case CIMType::REAL32: |
_rep = new CIMValueRep; |
_Dec(_u._real32Array); |
CIMValueType<CIMInstance>::set(_rep, x.clone()); |
break; |
} |
|
CIMValue::CIMValue(const Array<Boolean>& x) |
|
{ |
|
_rep = new CIMValueRep; |
|
CIMValueType<Boolean>::setArray(_rep, x); |
|
} |
| |
case CIMType::REAL64: |
CIMValue::CIMValue(const Array<Uint8>& x) |
_Dec(_u._real64Array); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Uint8>::setArray(_rep, x); |
|
} |
| |
case CIMType::CHAR16: |
CIMValue::CIMValue(const Array<Sint8>& x) |
_Dec(_u._char16Array); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Sint8>::setArray(_rep, x); |
|
} |
| |
case CIMType::STRING: |
CIMValue::CIMValue(const Array<Uint16>& x) |
_Dec(_u._stringArray); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Uint16>::setArray(_rep, x); |
|
} |
| |
case CIMType::DATETIME: |
CIMValue::CIMValue(const Array<Sint16>& x) |
_Dec(_u._dateTimeArray); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Sint16>::setArray(_rep, x); |
} | } |
|
|
|
CIMValue::CIMValue(const Array<Uint32>& x) |
|
{ |
|
_rep = new CIMValueRep; |
|
CIMValueType<Uint32>::setArray(_rep, x); |
} | } |
else |
|
|
CIMValue::CIMValue(const Array<Sint32>& x) |
{ | { |
switch (_type) |
_rep = new CIMValueRep; |
|
CIMValueType<Sint32>::setArray(_rep, x); |
|
} |
|
|
|
CIMValue::CIMValue(const Array<Uint64>& x) |
{ | { |
case CIMType::BOOLEAN: |
_rep = new CIMValueRep; |
case CIMType::UINT8: |
CIMValueType<Uint64>::setArray(_rep, x); |
case CIMType::SINT8: |
} |
case CIMType::UINT16: |
|
case CIMType::SINT16: |
|
case CIMType::UINT32: |
|
case CIMType::SINT32: |
|
case CIMType::UINT64: |
|
case CIMType::SINT64: |
|
case CIMType::REAL32: |
|
case CIMType::REAL64: |
|
case CIMType::CHAR16: |
|
break; |
|
| |
case CIMType::STRING: |
CIMValue::CIMValue(const Array<Sint64>& x) |
delete _u._stringValue; |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Sint64>::setArray(_rep, x); |
|
} |
| |
case CIMType::DATETIME: |
CIMValue::CIMValue(const Array<Real32>& x) |
delete _u._dateTimeValue; |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Real32>::setArray(_rep, x); |
|
} |
| |
case CIMType::REFERENCE: |
CIMValue::CIMValue(const Array<Real64>& x) |
delete _u._referenceValue; |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Real64>::setArray(_rep, x); |
} | } |
|
|
|
CIMValue::CIMValue(const Array<Char16>& x) |
|
{ |
|
_rep = new CIMValueRep; |
|
CIMValueType<Char16>::setArray(_rep, x); |
} | } |
| |
_init(); |
CIMValue::CIMValue(const Array<String>& x) |
|
{ |
|
_rep = new CIMValueRep; |
|
CIMValueType<String>::setArray(_rep, x); |
} | } |
| |
void CIMValue::toXml(Array<Sint8>& out) const |
CIMValue::CIMValue(const Array<CIMDateTime>& x) |
{ | { |
if (_isArray) |
_rep = new CIMValueRep; |
|
CIMValueType<CIMDateTime>::setArray(_rep, x); |
|
} |
|
|
|
CIMValue::CIMValue(const Array<CIMObjectPath>& x) |
{ | { |
out << "<VALUE.ARRAY>\n"; |
_rep = new CIMValueRep; |
|
CIMValueType<CIMObjectPath>::setArray(_rep, x); |
|
} |
| |
switch (_type) |
CIMValue::CIMValue(const Array<CIMObject>& x) |
{ | { |
case CIMType::BOOLEAN: |
Array<CIMObject> tmp; |
|
|
|
for (Uint32 i = 0, n = x.size(); i < n; i++) |
{ | { |
for (Uint32 i = 0, n = _u._booleanArray->size; i < n; i++) |
if (x[i].isUninitialized()) |
{ | { |
out << "<VALUE>"; |
// Bug 3373, throw exception on uninitialized object. |
_toXml(out, Boolean(_u._booleanArray->data()[i])); |
_rep = &CIMValueRep::_emptyRep; |
out << "</VALUE>\n"; |
throw UninitializedObjectException(); |
} | } |
break; |
|
|
tmp.append(x[i].clone()); |
} | } |
| |
case CIMType::UINT8: |
_rep = new CIMValueRep; |
_toXml(out, _u._uint8Array->data(), _u._uint8Array->size); |
CIMValueType<CIMObject>::setArray(_rep, tmp); |
break; |
} |
| |
case CIMType::SINT8: |
CIMValue::CIMValue(const Array<CIMInstance>& x) |
_toXml(out, _u._sint8Array->data(), _u._sint8Array->size); |
{ |
break; |
Array<CIMInstance> tmp; |
| |
case CIMType::UINT16: |
for (Uint32 i = 0, n = x.size(); i < n; i++) |
_toXml(out, _u._uint16Array->data(), _u._uint16Array->size); |
{ |
break; |
if (x[i].isUninitialized()) |
|
{ |
|
// Bug 3373, throw exception on uninitialized object. |
|
_rep = &CIMValueRep::_emptyRep; |
|
throw UninitializedObjectException(); |
|
} |
| |
case CIMType::SINT16: |
tmp.append(x[i].clone()); |
_toXml(out, _u._sint16Array->data(), _u._sint16Array->size); |
} |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<CIMInstance>::setArray(_rep, tmp); |
|
} |
| |
case CIMType::UINT32: |
void CIMValue::clear() |
_toXml(out, _u._uint32Array->data(), _u._uint32Array->size); |
{ |
break; |
CIMValueRep::unref(_rep); |
|
_rep = &CIMValueRep::_emptyRep; |
|
} |
| |
case CIMType::SINT32: |
CIMValue& CIMValue::operator=(const CIMValue& x) |
_toXml(out, _u._sint32Array->data(), _u._sint32Array->size); |
{ |
break; |
if (_rep != x._rep) |
|
{ |
|
CIMValueRep::unref(_rep); |
|
CIMValueRep::ref(_rep = x._rep); |
|
} |
| |
case CIMType::UINT64: |
return *this; |
_toXml(out, _u._uint64Array->data(), _u._uint64Array->size); |
} |
break; |
|
| |
case CIMType::SINT64: |
void CIMValue::assign(const CIMValue& x) |
_toXml(out, _u._sint64Array->data(), _u._sint64Array->size); |
{ |
break; |
if (_rep != x._rep) |
|
{ |
|
CIMValueRep::unref(_rep); |
|
CIMValueRep::ref(_rep = x._rep); |
|
} |
|
} |
| |
case CIMType::REAL32: |
Boolean CIMValue::typeCompatible(const CIMValue& x) const |
_toXml(out, _u._real32Array->data(), _u._real32Array->size); |
{ |
break; |
return (_rep->type == x._rep->type && _rep->isArray == x._rep->isArray); |
|
} |
| |
case CIMType::REAL64: |
Uint32 CIMValue::getArraySize() const |
_toXml(out, _u._real64Array->data(), _u._real64Array->size); |
{ |
break; |
if (!_rep->isArray) |
|
return 0; |
| |
case CIMType::CHAR16: |
switch (_rep->type) |
_toXml(out, _u._char16Array->data(), _u._char16Array->size); |
{ |
break; |
case CIMTYPE_BOOLEAN: |
|
return CIMValueType<Boolean>::arraySize(_rep); |
| |
case CIMType::STRING: |
case CIMTYPE_UINT8: |
_toXml(out, _u._stringArray->data(), _u._stringArray->size); |
return CIMValueType<Uint8>::arraySize(_rep); |
break; |
|
| |
case CIMType::DATETIME: |
case CIMTYPE_SINT8: |
_toXml(out, _u._dateTimeArray->data(), _u._dateTimeArray->size); |
return CIMValueType<Sint8>::arraySize(_rep); |
break; |
|
} |
case CIMTYPE_UINT16: |
|
return CIMValueType<Uint16>::arraySize(_rep); |
|
|
|
case CIMTYPE_SINT16: |
|
return CIMValueType<Sint16>::arraySize(_rep); |
| |
out << "</VALUE.ARRAY>\n"; |
case CIMTYPE_UINT32: |
|
return CIMValueType<Uint32>::arraySize(_rep); |
|
|
|
case CIMTYPE_SINT32: |
|
return CIMValueType<Sint32>::arraySize(_rep); |
|
|
|
case CIMTYPE_UINT64: |
|
return CIMValueType<Uint64>::arraySize(_rep); |
|
|
|
case CIMTYPE_SINT64: |
|
return CIMValueType<Sint64>::arraySize(_rep); |
|
|
|
case CIMTYPE_REAL32: |
|
return CIMValueType<Real32>::arraySize(_rep); |
|
|
|
case CIMTYPE_REAL64: |
|
return CIMValueType<Real64>::arraySize(_rep); |
|
|
|
case CIMTYPE_CHAR16: |
|
return CIMValueType<Char16>::arraySize(_rep); |
|
|
|
case CIMTYPE_STRING: |
|
return CIMValueType<String>::arraySize(_rep); |
|
|
|
case CIMTYPE_DATETIME: |
|
return CIMValueType<CIMDateTime>::arraySize(_rep); |
|
|
|
case CIMTYPE_REFERENCE: |
|
return CIMValueType<CIMObjectPath>::arraySize(_rep); |
|
|
|
case CIMTYPE_OBJECT: |
|
return CIMValueType<CIMObject>::arraySize(_rep); |
|
case CIMTYPE_INSTANCE: |
|
return CIMValueType<CIMInstance>::arraySize(_rep); |
|
default: |
|
PEGASUS_ASSERT(0); |
} | } |
else if (_type == CIMType::REFERENCE) |
|
{ |
return 0; |
_u._referenceValue->toXml(out); |
|
} | } |
else |
|
|
void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize) |
{ | { |
out << "<VALUE>"; |
// |
|
// Release any memory: |
|
// |
|
|
|
_release(_rep); |
|
|
|
// |
|
// Set the null value: |
|
// |
| |
switch (_type) |
switch (type) |
{ | { |
case CIMType::BOOLEAN: |
case CIMTYPE_BOOLEAN: |
_toXml(out, Boolean(_u._booleanValue != 0)); |
CIMValueType<Boolean>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::UINT8: |
case CIMTYPE_UINT8: |
_toXml(out, _u._uint8Value); |
CIMValueType<Uint8>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::SINT8: |
case CIMTYPE_SINT8: |
_toXml(out, _u._sint8Value); |
CIMValueType<Sint8>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::UINT16: |
case CIMTYPE_UINT16: |
_toXml(out, _u._uint16Value); |
CIMValueType<Uint16>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::SINT16: |
case CIMTYPE_SINT16: |
_toXml(out, _u._sint16Value); |
CIMValueType<Sint16>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::UINT32: |
case CIMTYPE_UINT32: |
_toXml(out, _u._uint32Value); |
CIMValueType<Uint32>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::SINT32: |
case CIMTYPE_SINT32: |
_toXml(out, _u._sint32Value); |
CIMValueType<Sint32>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::UINT64: |
case CIMTYPE_UINT64: |
_toXml(out, _u._uint64Value); |
CIMValueType<Uint64>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::SINT64: |
case CIMTYPE_SINT64: |
_toXml(out, _u._sint64Value); |
CIMValueType<Sint64>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::REAL32: |
case CIMTYPE_REAL32: |
_toXml(out, _u._real32Value); |
CIMValueType<Real32>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::REAL64: |
case CIMTYPE_REAL64: |
_toXml(out, _u._real64Value); |
CIMValueType<Real64>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::CHAR16: |
case CIMTYPE_CHAR16: |
_toXml(out, Char16(_u._char16Value)); |
CIMValueType<Char16>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::STRING: |
case CIMTYPE_STRING: |
_toXml(out, *_u._stringValue); |
CIMValueType<String>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMType::DATETIME: |
case CIMTYPE_DATETIME: |
_toXml(out, *_u._dateTimeValue); |
CIMValueType<CIMDateTime>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
} |
|
| |
out << "</VALUE>\n"; |
case CIMTYPE_REFERENCE: |
} |
CIMValueType<CIMObjectPath>::setNull(_rep, type, isArray,arraySize); |
} |
break; |
| |
void CIMValue::print() const |
case CIMTYPE_OBJECT: |
{ |
CIMValueType<CIMObject>::setNull(_rep, type, isArray, arraySize); |
Array<Sint8> tmp; |
break; |
toXml(tmp); |
case CIMTYPE_INSTANCE: |
tmp.append('\0'); |
CIMValueType<CIMInstance>::setNull(_rep, type, isArray, arraySize); |
std::cout << tmp.getData() << std::endl; |
break; |
|
default: |
|
PEGASUS_ASSERT(0); |
|
} |
} | } |
| |
void CIMValue::set(Boolean x) | void CIMValue::set(Boolean x) |
{ | { |
clear(); |
_release(_rep); |
_u._booleanValue = (Uint8)x; |
CIMValueType<Boolean>::set(_rep, x); |
_type = CIMType::BOOLEAN; |
|
} | } |
| |
void CIMValue::set(Uint8 x) | void CIMValue::set(Uint8 x) |
{ | { |
clear(); |
_release(_rep); |
_u._uint8Value = x; |
CIMValueType<Uint8>::set(_rep, x); |
_type = CIMType::UINT8; |
|
} | } |
| |
void CIMValue::set(Sint8 x) | void CIMValue::set(Sint8 x) |
{ | { |
clear(); |
_release(_rep); |
_u._sint8Value = x; |
CIMValueType<Sint8>::set(_rep, x); |
_type = CIMType::SINT8; |
|
} | } |
| |
void CIMValue::set(Uint16 x) | void CIMValue::set(Uint16 x) |
{ | { |
clear(); |
_release(_rep); |
_u._uint16Value = x; |
CIMValueType<Uint16>::set(_rep, x); |
_type = CIMType::UINT16; |
|
} | } |
| |
void CIMValue::set(Sint16 x) | void CIMValue::set(Sint16 x) |
{ | { |
clear(); |
_release(_rep); |
_u._sint16Value = x; |
CIMValueType<Sint16>::set(_rep, x); |
_type = CIMType::SINT16; |
|
} | } |
| |
void CIMValue::set(Uint32 x) | void CIMValue::set(Uint32 x) |
{ | { |
clear(); |
_release(_rep); |
_u._uint32Value = x; |
CIMValueType<Uint32>::set(_rep, x); |
_type = CIMType::UINT32; |
|
} | } |
| |
void CIMValue::set(Sint32 x) | void CIMValue::set(Sint32 x) |
{ | { |
clear(); |
_release(_rep); |
_u._sint32Value = x; |
CIMValueType<Sint32>::set(_rep, x); |
_type = CIMType::SINT32; |
|
} | } |
| |
void CIMValue::set(Uint64 x) | void CIMValue::set(Uint64 x) |
{ | { |
clear(); |
_release(_rep); |
_u._uint64Value = x; |
CIMValueType<Uint64>::set(_rep, x); |
_type = CIMType::UINT64; |
|
} | } |
| |
void CIMValue::set(Sint64 x) | void CIMValue::set(Sint64 x) |
{ | { |
clear(); |
_release(_rep); |
_u._sint64Value = x; |
CIMValueType<Sint64>::set(_rep, x); |
_type = CIMType::SINT64; |
|
} | } |
| |
void CIMValue::set(Real32 x) | void CIMValue::set(Real32 x) |
{ | { |
clear(); |
_release(_rep); |
_u._real32Value = x; |
CIMValueType<Real32>::set(_rep, x); |
_type = CIMType::REAL32; |
|
} | } |
| |
void CIMValue::set(Real64 x) | void CIMValue::set(Real64 x) |
{ | { |
clear(); |
_release(_rep); |
_u._real64Value = x; |
CIMValueType<Real64>::set(_rep, x); |
_type = CIMType::REAL64; |
|
} | } |
| |
void CIMValue::set(const Char16& x) | void CIMValue::set(const Char16& x) |
{ | { |
clear(); |
_release(_rep); |
_u._char16Value = x; |
CIMValueType<Char16>::set(_rep, x); |
_type = CIMType::CHAR16; |
|
} | } |
| |
void CIMValue::set(const String& x) | void CIMValue::set(const String& x) |
{ | { |
clear(); |
_release(_rep); |
_u._stringValue = new String(x); |
CIMValueType<String>::set(_rep, x); |
_type = CIMType::STRING; |
|
} | } |
| |
void CIMValue::set(const char* x) |
void CIMValue::set(const CIMDateTime& x) |
{ | { |
set(String(x)); |
_release(_rep); |
|
CIMValueType<CIMDateTime>::set(_rep, x); |
} | } |
| |
void CIMValue::set(const CIMDateTime& x) |
void CIMValue::set(const CIMObjectPath& x) |
|
{ |
|
_release(_rep); |
|
CIMValueType<CIMObjectPath>::set(_rep, x); |
|
} |
|
|
|
void CIMValue::set(const CIMObject& x) |
{ | { |
clear(); |
if (x.isUninitialized()) |
_u._dateTimeValue = new CIMDateTime(x); |
{ |
_type = CIMType::DATETIME; |
// Bug 3373, throw exception on uninitialized object. |
|
throw UninitializedObjectException(); |
} | } |
| |
void CIMValue::set(const CIMReference& x) |
_release(_rep); |
|
CIMValueType<CIMObject>::set(_rep, x.clone()); |
|
} |
|
void CIMValue::set(const CIMInstance& x) |
{ | { |
clear(); |
if (x.isUninitialized()) |
_u._referenceValue = new CIMReference(x); |
{ |
_type = CIMType::REFERENCE; |
// Bug 3373, throw exception on uninitialized object. |
|
throw UninitializedObjectException(); |
} | } |
| |
|
_release(_rep); |
|
CIMValueType<CIMInstance>::set(_rep, x.clone()); |
|
} |
void CIMValue::set(const Array<Boolean>& x) | void CIMValue::set(const Array<Boolean>& x) |
{ | { |
clear(); |
_release(_rep); |
_Inc(_u._booleanArray = x._rep); |
CIMValueType<Boolean>::setArray(_rep, x); |
_type = CIMType::BOOLEAN; |
|
_isArray = true; |
|
} | } |
| |
void CIMValue::set(const Array<Uint8>& x) | void CIMValue::set(const Array<Uint8>& x) |
{ | { |
clear(); |
_release(_rep); |
_Inc(_u._uint8Array = x._rep); |
CIMValueType<Uint8>::setArray(_rep, x); |
_type = CIMType::UINT8; |
|
_isArray = true; |
|
} | } |
| |
void CIMValue::set(const Array<Sint8>& x) | void CIMValue::set(const Array<Sint8>& x) |
{ | { |
clear(); |
_release(_rep); |
_Inc(_u._sint8Array = x._rep); |
CIMValueType<Sint8>::setArray(_rep, x); |
_type = CIMType::SINT8; |
|
_isArray = true; |
|
} | } |
| |
void CIMValue::set(const Array<Uint16>& x) | void CIMValue::set(const Array<Uint16>& x) |
{ | { |
clear(); |
_release(_rep); |
_Inc(_u._uint16Array = x._rep); |
CIMValueType<Uint16>::setArray(_rep, x); |
_type = CIMType::UINT16; |
|
_isArray = true; |
|
} | } |
| |
void CIMValue::set(const Array<Sint16>& x) | void CIMValue::set(const Array<Sint16>& x) |
{ | { |
clear(); |
_release(_rep); |
_Inc(_u._sint16Array = x._rep); |
CIMValueType<Sint16>::setArray(_rep, x); |
_type = CIMType::SINT16; |
|
_isArray = true; |
|
} | } |
| |
void CIMValue::set(const Array<Uint32>& x) | void CIMValue::set(const Array<Uint32>& x) |
{ | { |
clear(); |
_release(_rep); |
_Inc(_u._uint32Array = x._rep); |
CIMValueType<Uint32>::setArray(_rep, x); |
_type = CIMType::UINT32; |
|
_isArray = true; |
|
} | } |
| |
void CIMValue::set(const Array<Sint32>& x) | void CIMValue::set(const Array<Sint32>& x) |
{ | { |
clear(); |
_release(_rep); |
_Inc(_u._sint32Array = x._rep); |
CIMValueType<Sint32>::setArray(_rep, x); |
_type = CIMType::SINT32; |
|
_isArray = true; |
|
} | } |
| |
void CIMValue::set(const Array<Uint64>& x) | void CIMValue::set(const Array<Uint64>& x) |
{ | { |
clear(); |
_release(_rep); |
_Inc(_u._uint64Array = x._rep); |
CIMValueType<Uint64>::setArray(_rep, x); |
_type = CIMType::UINT64; |
|
_isArray = true; |
|
} | } |
| |
void CIMValue::set(const Array<Sint64>& x) | void CIMValue::set(const Array<Sint64>& x) |
{ | { |
clear(); |
_release(_rep); |
_Inc(_u._sint64Array = x._rep); |
CIMValueType<Sint64>::setArray(_rep, x); |
_type = CIMType::SINT64; |
|
_isArray = true; |
|
} | } |
| |
void CIMValue::set(const Array<Real32>& x) | void CIMValue::set(const Array<Real32>& x) |
{ | { |
clear(); |
_release(_rep); |
_Inc(_u._real32Array = x._rep); |
CIMValueType<Real32>::setArray(_rep, x); |
_type = CIMType::REAL32; |
|
_isArray = true; |
|
} | } |
| |
void CIMValue::set(const Array<Real64>& x) | void CIMValue::set(const Array<Real64>& x) |
{ | { |
clear(); |
_release(_rep); |
_Inc(_u._real64Array = x._rep); |
CIMValueType<Real64>::setArray(_rep, x); |
_type = CIMType::REAL64; |
|
_isArray = true; |
|
} | } |
| |
void CIMValue::set(const Array<Char16>& x) | void CIMValue::set(const Array<Char16>& x) |
{ | { |
clear(); |
_release(_rep); |
_Inc(_u._char16Array = x._rep); |
CIMValueType<Char16>::setArray(_rep, x); |
_type = CIMType::CHAR16; |
|
_isArray = true; |
|
} | } |
| |
void CIMValue::set(const Array<String>& x) | void CIMValue::set(const Array<String>& x) |
{ | { |
clear(); |
_release(_rep); |
_Inc(_u._stringArray = x._rep); |
CIMValueType<String>::setArray(_rep, x); |
_type = CIMType::STRING; |
|
_isArray = true; |
|
} | } |
| |
void CIMValue::set(const Array<CIMDateTime>& x) | void CIMValue::set(const Array<CIMDateTime>& x) |
{ | { |
clear(); |
_release(_rep); |
_Inc(_u._dateTimeArray = x._rep); |
CIMValueType<CIMDateTime>::setArray(_rep, x); |
_type = CIMType::DATETIME; |
} |
_isArray = true; |
|
|
void CIMValue::set(const Array<CIMObjectPath>& x) |
|
{ |
|
_release(_rep); |
|
CIMValueType<CIMObjectPath>::setArray(_rep, x); |
} | } |
| |
|
void CIMValue::set(const Array<CIMObject>& a) |
|
{ |
|
Array<CIMObject> tmp; |
|
|
|
for (Uint32 i = 0, n = a.size(); i < n; i++) |
|
{ |
|
if (a[i].isUninitialized()) |
|
{ |
|
// Bug 3373, throw exception on uninitialized object. |
|
throw UninitializedObjectException(); |
|
} |
|
|
|
tmp.append(a[i].clone()); |
|
} |
|
|
|
_release(_rep); |
|
CIMValueType<CIMObject>::setArray(_rep, tmp); |
|
} |
|
void CIMValue::set(const Array<CIMInstance>& a) |
|
{ |
|
Array<CIMInstance> tmp; |
|
|
|
for (Uint32 i = 0, n = a.size(); i < n; i++) |
|
{ |
|
if (a[i].isUninitialized()) |
|
{ |
|
// Bug 3373, throw exception on uninitialized object. |
|
throw UninitializedObjectException(); |
|
} |
|
|
|
tmp.append(a[i].clone()); |
|
} |
|
|
|
_release(_rep); |
|
CIMValueType<CIMInstance>::setArray(_rep, tmp); |
|
} |
void CIMValue::get(Boolean& x) const | void CIMValue::get(Boolean& x) const |
{ | { |
if (_type != CIMType::BOOLEAN || _isArray) |
if (_rep->type != CIMTYPE_BOOLEAN || _rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x = _u._booleanValue != 0; |
if (!_rep->isNull) |
|
x = CIMValueType<Boolean>::ref(_rep); |
} | } |
| |
void CIMValue::get(Uint8& x) const | void CIMValue::get(Uint8& x) const |
{ | { |
if (_type != CIMType::UINT8 || _isArray) |
if (_rep->type != CIMTYPE_UINT8 || _rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x = _u._uint8Value; |
if (!_rep->isNull) |
|
x = CIMValueType<Uint8>::ref(_rep); |
} | } |
| |
void CIMValue::get(Sint8& x) const | void CIMValue::get(Sint8& x) const |
{ | { |
if (_type != CIMType::SINT8 || _isArray) |
if (_rep->type != CIMTYPE_SINT8 || _rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x = _u._sint8Value; |
if (!_rep->isNull) |
|
x = CIMValueType<Sint8>::ref(_rep); |
} | } |
| |
void CIMValue::get(Uint16& x) const | void CIMValue::get(Uint16& x) const |
{ | { |
if (_type != CIMType::UINT16 || _isArray) |
if (_rep->type != CIMTYPE_UINT16 || _rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x = _u._uint16Value; |
if (!_rep->isNull) |
|
x = CIMValueType<Uint16>::ref(_rep); |
} | } |
| |
void CIMValue::get(Sint16& x) const | void CIMValue::get(Sint16& x) const |
{ | { |
if (_type != CIMType::SINT16 || _isArray) |
if (_rep->type != CIMTYPE_SINT16 || _rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x = _u._sint16Value; |
if (!_rep->isNull) |
|
x = CIMValueType<Sint16>::ref(_rep); |
} | } |
| |
|
|
void CIMValue::get(Uint32& x) const | void CIMValue::get(Uint32& x) const |
{ | { |
if (_type != CIMType::UINT32 || _isArray) |
if (_rep->type != CIMTYPE_UINT32 || _rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x = _u._uint32Value; |
if (!_rep->isNull) |
|
x = CIMValueType<Uint32>::ref(_rep); |
} | } |
| |
void CIMValue::get(Sint32& x) const | void CIMValue::get(Sint32& x) const |
{ | { |
if (_type != CIMType::SINT32 || _isArray) |
if (_rep->type != CIMTYPE_SINT32 || _rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x = _u._sint32Value; |
if (!_rep->isNull) |
|
x = CIMValueType<Sint32>::ref(_rep); |
} | } |
| |
void CIMValue::get(Uint64& x) const | void CIMValue::get(Uint64& x) const |
{ | { |
if (_type != CIMType::UINT64 || _isArray) |
if (_rep->type != CIMTYPE_UINT64 || _rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x = _u._uint64Value; |
if (!_rep->isNull) |
|
x = CIMValueType<Uint64>::ref(_rep); |
} | } |
| |
void CIMValue::get(Sint64& x) const | void CIMValue::get(Sint64& x) const |
{ | { |
if (_type != CIMType::SINT64 || _isArray) |
if (_rep->type != CIMTYPE_SINT64 || _rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x = _u._sint64Value; |
if (!_rep->isNull) |
|
x = CIMValueType<Sint64>::ref(_rep); |
} | } |
| |
void CIMValue::get(Real32& x) const | void CIMValue::get(Real32& x) const |
{ | { |
if (_type != CIMType::REAL32 || _isArray) |
if (_rep->type != CIMTYPE_REAL32 || _rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x = _u._real32Value; |
if (!_rep->isNull) |
|
x = CIMValueType<Real32>::ref(_rep); |
} | } |
| |
void CIMValue::get(Real64& x) const | void CIMValue::get(Real64& x) const |
{ | { |
if (_type != CIMType::REAL64 || _isArray) |
if (_rep->type != CIMTYPE_REAL64 || _rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x = _u._real64Value; |
if (!_rep->isNull) |
|
x = CIMValueType<Real64>::ref(_rep); |
} | } |
| |
void CIMValue::get(Char16& x) const | void CIMValue::get(Char16& x) const |
{ | { |
if (_type != CIMType::CHAR16 || _isArray) |
if (_rep->type != CIMTYPE_CHAR16 || _rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x = _u._char16Value; |
if (!_rep->isNull) |
|
x = CIMValueType<Char16>::ref(_rep); |
} | } |
| |
void CIMValue::get(String& x) const | void CIMValue::get(String& x) const |
{ | { |
if (_type != CIMType::STRING || _isArray) |
if (_rep->type != CIMTYPE_STRING || _rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x = *_u._stringValue; |
if (!_rep->isNull) |
|
x = CIMValueType<String>::ref(_rep); |
} | } |
| |
void CIMValue::get(CIMDateTime& x) const | void CIMValue::get(CIMDateTime& x) const |
{ | { |
if (_type != CIMType::DATETIME || _isArray) |
if (_rep->type != CIMTYPE_DATETIME || _rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
|
|
|
if (!_rep->isNull) |
|
x = CIMValueType<CIMDateTime>::ref(_rep); |
|
} |
|
|
|
void CIMValue::get(CIMObjectPath& x) const |
|
{ |
|
if (_rep->type != CIMTYPE_REFERENCE || _rep->isArray) |
|
throw TypeMismatchException(); |
| |
x = *_u._dateTimeValue; |
if (!_rep->isNull) |
|
x = CIMValueType<CIMObjectPath>::ref(_rep); |
} | } |
| |
void CIMValue::get(CIMReference& x) const |
void CIMValue::get(CIMObject& x) const |
{ | { |
if (_type != CIMType::REFERENCE || _isArray) |
if (_rep->type != CIMTYPE_OBJECT || _rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x = *_u._referenceValue; |
if (!_rep->isNull) |
|
// We have to clone our own unique copy since we are about to |
|
// return an object to the caller that he can modify; thereby, |
|
// changing the one we refer to as well. |
|
x = CIMValueType<CIMObject>::ref(_rep).clone(); |
} | } |
|
void CIMValue::get(CIMInstance& x) const |
|
{ |
|
if (_rep->type != CIMTYPE_INSTANCE || _rep->isArray) |
|
throw TypeMismatchException(); |
| |
|
if (!_rep->isNull) |
|
{ |
|
// We have to clone our own unique copy since we are about to |
|
// return an object to the caller that he can modify; thereby, |
|
// changing the one we refer to as well. |
|
x = CIMValueType<CIMInstance>::ref(_rep).clone(); |
|
} |
|
} |
void CIMValue::get(Array<Boolean>& x) const | void CIMValue::get(Array<Boolean>& x) const |
{ | { |
if (_type != CIMType::BOOLEAN || !_isArray) |
if (_rep->type != CIMTYPE_BOOLEAN || !_rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_u._booleanArray); |
if (!_rep->isNull) |
|
x = CIMValueType<Boolean>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Uint8>& x) const | void CIMValue::get(Array<Uint8>& x) const |
{ | { |
if (_type != CIMType::UINT8 || !_isArray) |
if (_rep->type != CIMTYPE_UINT8 || !_rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_u._uint8Array); |
if (!_rep->isNull) |
|
x = CIMValueType<Uint8>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Sint8>& x) const | void CIMValue::get(Array<Sint8>& x) const |
{ | { |
if (_type != CIMType::SINT8 || !_isArray) |
if (_rep->type != CIMTYPE_SINT8 || !_rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_u._sint8Array); |
if (!_rep->isNull) |
|
x = CIMValueType<Sint8>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Uint16>& x) const | void CIMValue::get(Array<Uint16>& x) const |
{ | { |
if (_type != CIMType::UINT16 || !_isArray) |
if (_rep->type != CIMTYPE_UINT16 || !_rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_u._uint16Array); |
if (!_rep->isNull) |
|
x = CIMValueType<Uint16>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Sint16>& x) const | void CIMValue::get(Array<Sint16>& x) const |
{ | { |
if (_type != CIMType::SINT16 || !_isArray) |
if (_rep->type != CIMTYPE_SINT16 || !_rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_u._sint16Array); |
if (!_rep->isNull) |
|
x = CIMValueType<Sint16>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Uint32>& x) const | void CIMValue::get(Array<Uint32>& x) const |
{ | { |
if (_type != CIMType::UINT32 || !_isArray) |
if (_rep->type != CIMTYPE_UINT32 || !_rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_u._uint32Array); |
if (!_rep->isNull) |
|
x = CIMValueType<Uint32>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Sint32>& x) const | void CIMValue::get(Array<Sint32>& x) const |
{ | { |
if (_type != CIMType::SINT32 || !_isArray) |
if (_rep->type != CIMTYPE_SINT32 || !_rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_u._sint32Array); |
if (!_rep->isNull) |
|
x = CIMValueType<Sint32>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Uint64>& x) const | void CIMValue::get(Array<Uint64>& x) const |
{ | { |
if (_type != CIMType::UINT64 || !_isArray) |
if (_rep->type != CIMTYPE_UINT64 || !_rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_u._uint64Array); |
if (!_rep->isNull) |
|
x = CIMValueType<Uint64>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Sint64>& x) const | void CIMValue::get(Array<Sint64>& x) const |
{ | { |
if (_type != CIMType::SINT64 || !_isArray) |
if (_rep->type != CIMTYPE_SINT64 || !_rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_u._sint64Array); |
if (!_rep->isNull) |
|
x = CIMValueType<Sint64>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Real32>& x) const | void CIMValue::get(Array<Real32>& x) const |
{ | { |
if (_type != CIMType::REAL32 || !_isArray) |
if (_rep->type != CIMTYPE_REAL32 || !_rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_u._real32Array); |
if (!_rep->isNull) |
|
x = CIMValueType<Real32>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Real64>& x) const | void CIMValue::get(Array<Real64>& x) const |
{ | { |
if (_type != CIMType::REAL64 || !_isArray) |
if (_rep->type != CIMTYPE_REAL64 || !_rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_u._real64Array); |
if (!_rep->isNull) |
|
x = CIMValueType<Real64>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Char16>& x) const | void CIMValue::get(Array<Char16>& x) const |
{ | { |
if (_type != CIMType::CHAR16 || !_isArray) |
if (_rep->type != CIMTYPE_CHAR16 || !_rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_u._char16Array); |
if (!_rep->isNull) |
|
x = CIMValueType<Char16>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<String>& x) const | void CIMValue::get(Array<String>& x) const |
{ | { |
if (_type != CIMType::STRING || !_isArray) |
if (_rep->type != CIMTYPE_STRING || !_rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_u._stringArray); |
if (!_rep->isNull) |
|
x = CIMValueType<String>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<CIMDateTime>& x) const | void CIMValue::get(Array<CIMDateTime>& x) const |
{ | { |
if (_type != CIMType::DATETIME || !_isArray) |
if (_rep->type != CIMTYPE_DATETIME || !_rep->isArray) |
throw TypeMismatch(); |
throw TypeMismatchException(); |
| |
x.set(_u._dateTimeArray); |
if (!_rep->isNull) |
|
x = CIMValueType<CIMDateTime>::aref(_rep); |
} | } |
| |
void CIMValue::_init() |
void CIMValue::get(Array<CIMObjectPath>& x) const |
{ | { |
_type = CIMType::NONE; |
if (_rep->type != CIMTYPE_REFERENCE || !_rep->isArray) |
_isArray = false; |
throw TypeMismatchException(); |
_u._voidPtr = 0; |
|
|
if (!_rep->isNull) |
|
x = CIMValueType<CIMObjectPath>::aref(_rep); |
} | } |
| |
Boolean operator==(const CIMValue& x, const CIMValue& y) |
void CIMValue::get(Array<CIMObject>& x) const |
{ | { |
if (!x.typeCompatible(y)) |
if (_rep->type != CIMTYPE_OBJECT || !_rep->isArray) |
|
throw TypeMismatchException(); |
|
|
|
if (!_rep->isNull) |
|
{ |
|
x.clear(); |
|
|
|
// We have to clone our own unique copy since we are about to |
|
// return an object to the caller that he can modify; thereby, |
|
// changing the one we refer to as well. |
|
for (Uint32 i = 0, n = CIMValueType<CIMObject>::arraySize(_rep); |
|
i < n; i++) |
|
{ |
|
x.append(CIMValueType<CIMObject>::aref(_rep)[i].clone()); |
|
} |
|
} |
|
} |
|
|
|
void CIMValue::get(Array<CIMInstance>& x) const |
|
{ |
|
if (_rep->type != CIMTYPE_INSTANCE || !_rep->isArray) |
|
throw TypeMismatchException(); |
|
|
|
if (!_rep->isNull) |
|
{ |
|
x.clear(); |
|
|
|
// We have to clone our own unique copy since we are about to |
|
// return an object to the caller that he can modify; thereby, |
|
// changing the one we refer to as well. |
|
for (Uint32 i = 0, n = CIMValueType<CIMInstance>::arraySize(_rep); |
|
i < n; i++) |
|
{ |
|
x.append(CIMValueType<CIMInstance>::aref(_rep)[i].clone()); |
|
} |
|
} |
|
} |
|
|
|
Boolean CIMValue::equal(const CIMValue& x) const |
|
{ |
|
if (!typeCompatible(x)) |
return false; | return false; |
| |
if (x._isArray) |
if (_rep->isNull != x._rep->isNull) |
|
return false; |
|
|
|
if (_rep->isNull) |
|
return true; |
|
|
|
if (_rep->isArray) |
{ | { |
switch (x._type) |
switch (_rep->type) |
{ | { |
case CIMType::BOOLEAN: |
case CIMTYPE_BOOLEAN: |
return Array<Boolean>(x._u._booleanArray) == |
return CIMValueType<Boolean>::equalArray(_rep, x._rep); |
Array<Boolean>(y._u._booleanArray); |
|
| |
case CIMType::UINT8: |
case CIMTYPE_UINT8: |
return Array<Uint8>(x._u._uint8Array) == |
return CIMValueType<Uint8>::equalArray(_rep, x._rep); |
Array<Uint8>(y._u._uint8Array); |
|
| |
case CIMType::SINT8: |
case CIMTYPE_SINT8: |
return Array<Sint8>(x._u._sint8Array) == |
return CIMValueType<Sint8>::equalArray(_rep, x._rep); |
Array<Sint8>(y._u._sint8Array); |
|
| |
case CIMType::UINT16: |
case CIMTYPE_UINT16: |
return Array<Uint16>(x._u._uint16Array) == |
return CIMValueType<Uint16>::equalArray(_rep, x._rep); |
Array<Uint16>(y._u._uint16Array); |
|
| |
case CIMType::SINT16: |
case CIMTYPE_SINT16: |
return Array<Sint16>(x._u._sint16Array) == |
return CIMValueType<Sint16>::equalArray(_rep, x._rep); |
Array<Sint16>(y._u._sint16Array); |
|
| |
case CIMType::UINT32: |
case CIMTYPE_UINT32: |
return Array<Uint32>(x._u._uint32Array) == |
return CIMValueType<Uint32>::equalArray(_rep, x._rep); |
Array<Uint32>(y._u._uint32Array); |
|
| |
case CIMType::SINT32: |
case CIMTYPE_SINT32: |
return Array<Sint32>(x._u._sint32Array) == |
return CIMValueType<Sint32>::equalArray(_rep, x._rep); |
Array<Sint32>(y._u._sint32Array); |
|
| |
case CIMType::UINT64: |
case CIMTYPE_UINT64: |
return Array<Uint64>(x._u._uint64Array) == |
return CIMValueType<Uint64>::equalArray(_rep, x._rep); |
Array<Uint64>(y._u._uint64Array); |
|
| |
case CIMType::SINT64: |
case CIMTYPE_SINT64: |
return Array<Sint64>(x._u._sint64Array) == |
return CIMValueType<Sint64>::equalArray(_rep, x._rep); |
Array<Sint64>(y._u._sint64Array); |
|
| |
case CIMType::REAL32: |
case CIMTYPE_REAL32: |
return Array<Real32>(x._u._real32Array) == |
return CIMValueType<Real32>::equalArray(_rep, x._rep); |
Array<Real32>(y._u._real32Array); |
|
| |
case CIMType::REAL64: |
case CIMTYPE_REAL64: |
return Array<Real64>(x._u._real64Array) == |
return CIMValueType<Real64>::equalArray(_rep, x._rep); |
Array<Real64>(y._u._real64Array); |
|
| |
case CIMType::CHAR16: |
case CIMTYPE_CHAR16: |
return Array<Char16>(x._u._char16Array) == |
return CIMValueType<Char16>::equalArray(_rep, x._rep); |
Array<Char16>(y._u._char16Array); |
|
| |
case CIMType::STRING: |
case CIMTYPE_STRING: |
return Array<String>(x._u._stringArray) == |
return CIMValueType<String>::equalArray(_rep, x._rep); |
Array<String>(y._u._stringArray); |
|
| |
case CIMType::DATETIME: |
case CIMTYPE_DATETIME: |
return Array<CIMDateTime>(x._u._dateTimeArray) == |
return CIMValueType<CIMDateTime>::equalArray(_rep, x._rep); |
Array<CIMDateTime>(y._u._dateTimeArray); |
|
|
case CIMTYPE_REFERENCE: |
|
return CIMValueType<CIMObjectPath>::equalArray(_rep, x._rep); |
|
|
|
case CIMTYPE_OBJECT: |
|
return CIMValueType<CIMObject>::equalArray(_rep, x._rep); |
|
case CIMTYPE_INSTANCE: |
|
return CIMValueType<CIMInstance>::equalArray(_rep, x._rep); |
|
default: |
|
PEGASUS_ASSERT(0); |
} | } |
} | } |
else | else |
{ | { |
switch (x._type) |
switch (_rep->type) |
{ | { |
case CIMType::BOOLEAN: |
case CIMTYPE_BOOLEAN: |
return x._u._booleanValue == y._u._booleanValue; |
return CIMValueType<Boolean>::equal(_rep, x._rep); |
| |
case CIMType::UINT8: |
case CIMTYPE_UINT8: |
return x._u._uint8Value == y._u._uint8Value; |
return CIMValueType<Uint8>::equal(_rep, x._rep); |
| |
case CIMType::SINT8: |
case CIMTYPE_SINT8: |
return x._u._sint8Value == y._u._sint8Value; |
return CIMValueType<Sint8>::equal(_rep, x._rep); |
| |
case CIMType::UINT16: |
case CIMTYPE_UINT16: |
return x._u._uint16Value == y._u._uint16Value; |
return CIMValueType<Uint16>::equal(_rep, x._rep); |
| |
case CIMType::SINT16: |
case CIMTYPE_SINT16: |
return x._u._sint16Value == y._u._sint16Value; |
return CIMValueType<Sint16>::equal(_rep, x._rep); |
| |
case CIMType::UINT32: |
case CIMTYPE_UINT32: |
return x._u._uint32Value == y._u._uint32Value; |
return CIMValueType<Uint32>::equal(_rep, x._rep); |
| |
case CIMType::SINT32: |
case CIMTYPE_SINT32: |
return x._u._sint32Value == y._u._sint32Value; |
return CIMValueType<Sint32>::equal(_rep, x._rep); |
| |
case CIMType::UINT64: |
case CIMTYPE_UINT64: |
return x._u._uint64Value == y._u._uint64Value; |
return CIMValueType<Uint64>::equal(_rep, x._rep); |
| |
case CIMType::SINT64: |
case CIMTYPE_SINT64: |
return x._u._sint64Value == y._u._sint64Value; |
return CIMValueType<Sint64>::equal(_rep, x._rep); |
| |
case CIMType::REAL32: |
case CIMTYPE_REAL32: |
return x._u._real32Value == y._u._real32Value; |
return CIMValueType<Real32>::equal(_rep, x._rep); |
| |
case CIMType::REAL64: |
case CIMTYPE_REAL64: |
return x._u._real64Value == y._u._real64Value; |
return CIMValueType<Real64>::equal(_rep, x._rep); |
| |
case CIMType::CHAR16: |
case CIMTYPE_CHAR16: |
return x._u._char16Value == y._u._char16Value; |
return CIMValueType<Char16>::equal(_rep, x._rep); |
| |
case CIMType::STRING: |
case CIMTYPE_STRING: |
return String::equal(*x._u._stringValue, *y._u._stringValue); |
return CIMValueType<String>::equal(_rep, x._rep); |
| |
case CIMType::DATETIME: |
case CIMTYPE_DATETIME: |
return *x._u._dateTimeValue == *y._u._dateTimeValue; |
return CIMValueType<CIMDateTime>::equal(_rep, x._rep); |
| |
case CIMType::REFERENCE: |
case CIMTYPE_REFERENCE: |
return *x._u._referenceValue == *y._u._referenceValue; |
return CIMValueType<CIMObjectPath>::equal(_rep, x._rep); |
|
|
|
case CIMTYPE_OBJECT: |
|
return CIMValueType<CIMObject>::ref(_rep).identical( |
|
CIMValueType<CIMObject>::ref(x._rep)); |
|
case CIMTYPE_INSTANCE: |
|
return CIMValueType<CIMInstance>::ref(_rep).identical( |
|
CIMValueType<CIMInstance>::ref(x._rep)); |
|
default: |
|
PEGASUS_ASSERT(0); |
} | } |
} | } |
| |
// Unreachable! |
|
return false; | return false; |
} | } |
| |
void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize) |
String CIMValue::toString() const |
{ |
|
clear(); |
|
|
|
if (isArray) |
|
{ |
|
switch (type) |
|
{ | { |
case CIMType::BOOLEAN: |
Buffer out; |
set(Array<Boolean>(arraySize)); |
|
break; |
|
| |
case CIMType::UINT8: |
// ATTN: Not sure what we should do with getstring for Null CIMValues |
set(Array<Uint8>(arraySize)); |
// Choice return empty string or exception out. |
break; |
|
|
|
case CIMType::SINT8: |
|
set(Array<Sint8>(arraySize)); |
|
break; |
|
| |
case CIMType::UINT16: |
if (_rep->isNull) |
set(Array<Uint16>(arraySize)); |
return String(); |
break; |
|
| |
case CIMType::SINT16: |
if (_rep->isArray) |
set(Array<Sint16>(arraySize)); |
{ |
break; |
switch (_rep->type) |
|
{ |
case CIMType::UINT32: |
case CIMTYPE_BOOLEAN: |
set(Array<Uint32>(arraySize)); |
{ |
break; |
const Array<Boolean>& a = CIMValueType<Boolean>::aref(_rep); |
|
Uint32 size = a.size(); |
case CIMType::SINT32: |
|
set(Array<Sint32>(arraySize)); |
|
break; |
|
|
|
case CIMType::UINT64: |
|
set(Array<Uint64>(arraySize)); |
|
break; |
|
|
|
case CIMType::SINT64: |
|
set(Array<Sint64>(arraySize)); |
|
break; |
|
|
|
case CIMType::REAL32: |
|
set(Array<Real32>(arraySize)); |
|
break; |
|
|
|
case CIMType::REAL64: |
|
set(Array<Real64>(arraySize)); |
|
break; |
|
|
|
case CIMType::CHAR16: |
|
set(Array<Char16>(arraySize)); |
|
break; |
|
| |
case CIMType::STRING: |
for (Uint32 i = 0; i < size; i++) |
set(Array<String>(arraySize)); |
{ |
|
_toString(out, a[i]); |
|
out.append(' '); |
|
} |
break; | break; |
|
} |
| |
case CIMType::DATETIME: |
case CIMTYPE_UINT8: |
set(Array<CIMDateTime>(arraySize)); |
{ |
|
const Array<Uint8>& a = CIMValueType<Uint8>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
} | } |
} |
|
else |
case CIMTYPE_SINT8: |
{ |
|
switch (type) |
|
{ | { |
case CIMType::BOOLEAN: |
const Array<Sint8>& a = CIMValueType<Sint8>::aref(_rep); |
set(false); |
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMType::UINT8: |
case CIMTYPE_UINT16: |
set(Uint8(0)); |
{ |
|
const Array<Uint16>& a = CIMValueType<Uint16>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMType::SINT8: |
case CIMTYPE_SINT16: |
set(Sint8(0)); |
{ |
|
const Array<Sint16>& a = CIMValueType<Sint16>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMType::UINT16: |
case CIMTYPE_UINT32: |
set(Uint16(0)); |
{ |
|
const Array<Uint32>& a = CIMValueType<Uint32>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMType::SINT16: |
case CIMTYPE_SINT32: |
set(Sint16(0)); |
{ |
|
const Array<Sint32>& a = CIMValueType<Sint32>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMType::UINT32: |
case CIMTYPE_UINT64: |
set(Uint32(0)); |
{ |
|
const Array<Uint64>& a = CIMValueType<Uint64>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMType::SINT32: |
case CIMTYPE_SINT64: |
set(Sint32(0)); |
{ |
|
const Array<Sint64>& a = CIMValueType<Sint64>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMType::UINT64: |
case CIMTYPE_REAL32: |
set(Uint64(0)); |
{ |
|
const Array<Real32>& a = CIMValueType<Real32>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMType::SINT64: |
case CIMTYPE_REAL64: |
set(Sint64(0)); |
{ |
|
const Array<Real64>& a = CIMValueType<Real64>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMType::REAL32: |
case CIMTYPE_CHAR16: |
set(Real32(0.0)); |
{ |
|
const Array<Char16>& a = CIMValueType<Char16>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMType::REAL64: |
case CIMTYPE_STRING: |
set(Real64(0.0)); |
{ |
|
const Array<String>& a = CIMValueType<String>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMType::CHAR16: |
case CIMTYPE_DATETIME: |
set(Char16(0)); |
{ |
|
const Array<CIMDateTime>& a = |
|
CIMValueType<CIMDateTime>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMType::STRING: |
case CIMTYPE_REFERENCE: |
set(String()); |
{ |
|
const Array<CIMObjectPath>& a = |
|
CIMValueType<CIMObjectPath>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMType::DATETIME: |
case CIMTYPE_OBJECT: |
set(CIMDateTime()); |
{ |
|
const Array<CIMObject>& a = CIMValueType<CIMObject>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
case CIMType::REFERENCE: |
case CIMTYPE_INSTANCE: |
set(CIMReference()); |
{ |
|
const Array<CIMInstance>& a = |
|
CIMValueType<CIMInstance>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
} | } |
|
default: |
|
PEGASUS_ASSERT(0); |
} | } |
} | } |
|
else |
String CIMValue::toString() const |
|
{ |
|
Array<Sint8> out; |
|
|
|
if (_isArray) |
|
{ |
|
switch (_type) |
|
{ |
|
case CIMType::BOOLEAN: |
|
{ | { |
for (Uint32 i = 0, n = _u._booleanArray->size; i < n; i++) |
switch (_rep->type) |
{ | { |
_toXml(out, Boolean(_u._booleanArray->data()[i])); |
case CIMTYPE_BOOLEAN: |
|
_toString(out, CIMValueType<Boolean>::ref(_rep)); |
out << " "; |
|
} |
|
break; | break; |
} |
|
| |
case CIMType::UINT8: |
case CIMTYPE_UINT8: |
_toStr(out, _u._uint8Array->data(), _u._uint8Array->size); |
_toString(out, CIMValueType<Uint8>::ref(_rep)); |
break; | break; |
| |
case CIMType::SINT8: |
case CIMTYPE_SINT8: |
_toStr(out, _u._sint8Array->data(), _u._sint8Array->size); |
_toString(out, CIMValueType<Sint8>::ref(_rep)); |
break; | break; |
| |
case CIMType::UINT16: |
case CIMTYPE_UINT16: |
_toStr(out, _u._uint16Array->data(), _u._uint16Array->size); |
_toString(out, CIMValueType<Uint16>::ref(_rep)); |
break; | break; |
| |
case CIMType::SINT16: |
case CIMTYPE_SINT16: |
_toStr(out, _u._sint16Array->data(), _u._sint16Array->size); |
_toString(out, CIMValueType<Sint16>::ref(_rep)); |
break; | break; |
| |
case CIMType::UINT32: |
case CIMTYPE_UINT32: |
_toStr(out, _u._uint32Array->data(), _u._uint32Array->size); |
_toString(out, CIMValueType<Uint32>::ref(_rep)); |
break; | break; |
| |
case CIMType::SINT32: |
case CIMTYPE_SINT32: |
_toStr(out, _u._sint32Array->data(), _u._sint32Array->size); |
_toString(out, CIMValueType<Sint32>::ref(_rep)); |
break; | break; |
| |
case CIMType::UINT64: |
case CIMTYPE_UINT64: |
_toStr(out, _u._uint64Array->data(), _u._uint64Array->size); |
_toString(out, CIMValueType<Uint64>::ref(_rep)); |
break; | break; |
| |
case CIMType::SINT64: |
case CIMTYPE_SINT64: |
_toStr(out, _u._sint64Array->data(), _u._sint64Array->size); |
_toString(out, CIMValueType<Sint64>::ref(_rep)); |
break; | break; |
| |
case CIMType::REAL32: |
case CIMTYPE_REAL32: |
_toStr(out, _u._real32Array->data(), _u._real32Array->size); |
_toString(out, CIMValueType<Real32>::ref(_rep)); |
break; | break; |
| |
case CIMType::REAL64: |
case CIMTYPE_REAL64: |
_toStr(out, _u._real64Array->data(), _u._real64Array->size); |
_toString(out, CIMValueType<Real64>::ref(_rep)); |
break; | break; |
| |
case CIMType::CHAR16: |
case CIMTYPE_CHAR16: |
_toStr(out, _u._char16Array->data(), _u._char16Array->size); |
_toString(out, CIMValueType<Char16>::ref(_rep)); |
break; | break; |
| |
case CIMType::STRING: |
case CIMTYPE_STRING: |
_toStr(out, _u._stringArray->data(), _u._stringArray->size); |
_toString(out, CIMValueType<String>::ref(_rep)); |
break; | break; |
| |
case CIMType::DATETIME: |
case CIMTYPE_DATETIME: |
_toStr(out, _u._dateTimeArray->data(), _u._dateTimeArray->size); |
_toString(out, CIMValueType<CIMDateTime>::ref(_rep)); |
break; |
|
} |
|
} |
|
else if (_type == CIMType::REFERENCE) |
|
{ |
|
// ATTN: work on this: |
|
} |
|
else |
|
{ |
|
switch (_type) |
|
{ |
|
case CIMType::BOOLEAN: |
|
_toXml(out, Boolean(_u._booleanValue != 0)); |
|
break; | break; |
| |
case CIMType::UINT8: |
case CIMTYPE_REFERENCE: |
_toXml(out, _u._uint8Value); |
_toString(out, CIMValueType<CIMObjectPath>::ref(_rep)); |
break; | break; |
| |
case CIMType::SINT8: |
case CIMTYPE_OBJECT: |
_toXml(out, _u._sint8Value); |
_toString(out, CIMValueType<CIMObject>::ref(_rep)); |
break; | break; |
|
case CIMTYPE_INSTANCE: |
case CIMType::UINT16: |
_toString(out, CIMValueType<CIMInstance>::ref(_rep)); |
_toXml(out, _u._uint16Value); |
|
break; | break; |
|
default: |
|
PEGASUS_ASSERT(0); |
|
} |
|
} |
| |
case CIMType::SINT16: |
return out.getData(); |
_toXml(out, _u._sint16Value); |
} |
break; |
|
| |
case CIMType::UINT32: |
#ifdef PEGASUS_USE_DEPRECATED_INTERFACES |
_toXml(out, _u._uint32Value); |
|
break; |
|
| |
case CIMType::SINT32: |
CIMValue::CIMValue(char x) |
_toXml(out, _u._sint32Value); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Sint8>::set(_rep, (Sint8)x); |
|
} |
| |
case CIMType::UINT64: |
CIMValue::CIMValue(const Array<char>& x) |
_toXml(out, _u._uint64Value); |
{ |
break; |
_rep = new CIMValueRep; |
|
Array<Sint8> tmp((Sint8*)x.getData(), x.size()); |
|
CIMValueType<Sint8>::setArray(_rep, tmp); |
|
} |
| |
case CIMType::SINT64: |
void CIMValue::set(char x) |
_toXml(out, _u._sint64Value); |
{ |
break; |
set(static_cast<Sint8>(x)); |
|
} |
| |
case CIMType::REAL32: |
void CIMValue::set(const Array<char>& x) |
_toXml(out, _u._real32Value); |
{ |
break; |
set(*reinterpret_cast<const Array<Sint8>*>(&x)); |
|
} |
| |
case CIMType::REAL64: |
void CIMValue::get(char& x) const |
_toXml(out, _u._real64Value); |
{ |
break; |
get(*reinterpret_cast<Sint8*>(&x)); |
|
} |
| |
case CIMType::CHAR16: |
void CIMValue::get(Array<char>& x) const |
_toXml(out, Char16(_u._char16Value)); |
{ |
break; |
get(*reinterpret_cast<Array<Sint8>*>(&x)); |
|
} |
| |
case CIMType::STRING: |
#endif /* PEGASUS_USE_DEPRECATED_INTERFACES */ |
_toXml(out, *_u._stringValue); |
|
break; |
|
| |
case CIMType::DATETIME: |
void CIMValue::_get(const String*& data, Uint32& size) const |
_toXml(out, *_u._dateTimeValue); |
{ |
break; |
const Array<String>& a = CIMValueType<String>::aref(_rep); |
|
data = a.getData(); |
|
size = a.size(); |
} | } |
|
|
|
Boolean operator==(const CIMValue& x, const CIMValue& y) |
|
{ |
|
return x.equal(y); |
} | } |
| |
out.append('\0'); |
Boolean operator!=(const CIMValue& x, const CIMValue& y) |
return out.getData(); |
{ |
|
return !x.equal(y); |
} | } |
| |
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |