version 1.49.4.1, 2004/11/12 17:48:28
|
version 1.63, 2005/11/27 03:11:36
|
|
|
//%2003//////////////////////////////////////////////////////////////////////// |
//%2005//////////////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Development |
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
// Company, L. P., IBM Corp., The Open Group, Tivoli Systems. |
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. |
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; | // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; |
// IBM Corp.; EMC Corporation, The Open Group. | // IBM Corp.; EMC Corporation, The Open Group. |
|
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; |
|
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
|
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; VERITAS Software 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 |
|
|
// Carol Ann Krug Graves, Hewlett-Packard Company | // Carol Ann Krug Graves, Hewlett-Packard Company |
// (carolann_graves@hp.com) | // (carolann_graves@hp.com) |
// Adriann Schuur (schuur@de.ibm.com) PEP 164 | // Adriann Schuur (schuur@de.ibm.com) PEP 164 |
|
// Dave Sudlik, IBM (dsudlik@us.ibm.com) |
|
// David Dillard, VERITAS Software Corp. |
|
// (david.dillard@veritas.com) |
|
// Mike Brasher, Inova Europe (mike-brasher@austin.rr.com) |
// | // |
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
|
|
#include "Indentor.h" | #include "Indentor.h" |
#include "XmlWriter.h" | #include "XmlWriter.h" |
#include "CommonUTF.h" | #include "CommonUTF.h" |
|
|
#include "CIMValueRep.h" | #include "CIMValueRep.h" |
|
#include "Config.h" |
|
#include "CIMType.h" |
|
#include "String.h" |
|
#include "CIMDateTime.h" |
|
#include "CIMObjectPath.h" |
|
#include "CIMObject.h" |
|
#include "Array.h" |
|
#include <Pegasus/Common/PegasusAssert.h> |
| |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
|
|
# include "ArrayImpl.h" | # include "ArrayImpl.h" |
#undef PEGASUS_ARRAY_T | #undef PEGASUS_ARRAY_T |
| |
//////////////////////////////////////////////////////////////////////////////// |
// ATTN: By getting a CIMObject from a CIMValue, the client of CIMValue can |
|
// modify the internals of that CIMObject and thus change what CIMValue |
|
// itself refers to. There are two solutions: clone() at ever juncture or |
|
// force CIMValue to make its own unique copy when the client calls get() |
|
// to get a CIMObject. |
| |
|
//============================================================================== |
// | // |
// _toString routines: |
// _toString() routines: |
// | // |
//////////////////////////////////////////////////////////////////////////////// |
//============================================================================== |
| |
inline void _toString(Array<Sint8>& out, Boolean x) |
inline void _toString(Buffer& out, Boolean x) |
{ | { |
XmlWriter::append(out, x); | XmlWriter::append(out, x); |
} | } |
| |
inline void _toString(Array<Sint8>& out, Uint8 x) { XmlWriter::append(out, Uint32(x)); } |
inline void _toString(Buffer& out, Uint8 x) |
inline void _toString(Array<Sint8>& out, Sint8 x) { XmlWriter::append(out, Sint32(x)); } |
|
inline void _toString(Array<Sint8>& out, Uint16 x) { XmlWriter::append(out, Uint32(x)); } |
|
inline void _toString(Array<Sint8>& out, Sint16 x) { XmlWriter::append(out, Sint32(x)); } |
|
inline void _toString(Array<Sint8>& out, Uint32 x) { XmlWriter::append(out, x); } |
|
inline void _toString(Array<Sint8>& out, Sint32 x) { XmlWriter::append(out, x); } |
|
inline void _toString(Array<Sint8>& out, Uint64 x) { XmlWriter::append(out, x); } |
|
inline void _toString(Array<Sint8>& out, Sint64 x) { XmlWriter::append(out, x); } |
|
inline void _toString(Array<Sint8>& out, Real32 x) { XmlWriter::append(out, Real64(x)); } |
|
inline void _toString(Array<Sint8>& out, Real64 x) { XmlWriter::append(out, x); } |
|
|
|
inline void _toString(Array<Sint8>& out, Char16 x) |
|
{ |
|
// We need to convert the Char16 to UTF8 then append the UTF8 |
|
// character into the array. |
|
// NOTE: The UTF8 character could be several bytes long. |
|
// WARNING: This function will put in replacement character for |
|
// all characters that have surogate pairs. |
|
|
|
char str[6]; |
|
memset(str,0x00,sizeof(str)); |
|
char* charIN = (char *)&x; |
|
|
|
const Uint16 *strsrc = (Uint16 *)charIN; |
|
Uint16 *endsrc = (Uint16 *)&charIN[1]; |
|
|
|
Uint8 *strtgt = (Uint8 *)str; |
|
Uint8 *endtgt = (Uint8 *)&str[5]; |
|
|
|
UTF16toUTF8(&strsrc, |
|
endsrc, |
|
&strtgt, |
|
endtgt); |
|
|
|
out.append((Sint8 *)str, UTF_8_COUNT_TRAIL_BYTES(str[0]) +1); |
|
} |
|
|
|
inline void _toString(Array<Sint8>& out, const String& x) |
|
{ |
|
out << x; |
|
} |
|
|
|
inline void _toString(Array<Sint8>& out, const CIMDateTime& x) |
|
{ |
|
out << x.toString(); |
|
} |
|
|
|
inline void _toString(Array<Sint8>& out, const CIMObjectPath& x) |
|
{ | { |
out << x.toString(); |
XmlWriter::append(out, Uint32(x)); |
} |
|
|
|
inline void _toString(Array<Sint8>& out, const CIMObject& x) |
|
{ |
|
out << x.toString(); |
|
} |
|
|
|
template<class T> |
|
void _toString(Array<Sint8>& out, const T* p, Uint32 size) |
|
{ |
|
while (size--) |
|
{ |
|
_toString(out, *p++); |
|
out << " "; |
|
} |
|
} |
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// CIMValue |
|
// |
|
//////////////////////////////////////////////////////////////////////////////// |
|
|
|
CIMValue::CIMValue() |
|
{ |
|
_rep = new CIMValueRep(); |
|
} |
|
|
|
CIMValue::CIMValue(CIMType type, Boolean isArray, Uint32 arraySize) |
|
{ |
|
_rep = new CIMValueRep(); |
|
setNullValue(type, isArray, arraySize); |
|
} | } |
| |
CIMValue::CIMValue(Boolean x) |
inline void _toString(Buffer& out, Sint8 x) |
{ | { |
_rep = new CIMValueRep(); |
XmlWriter::append(out, Sint32(x)); |
set(x); |
|
} | } |
| |
CIMValue::CIMValue(Uint8 x) |
inline void _toString(Buffer& out, Uint16 x) |
{ | { |
_rep = new CIMValueRep(); |
XmlWriter::append(out, Uint32(x)); |
set(x); |
|
} | } |
| |
CIMValue::CIMValue(Sint8 x) |
inline void _toString(Buffer& out, Sint16 x) |
{ | { |
_rep = new CIMValueRep(); |
XmlWriter::append(out, Sint32(x)); |
set(x); |
|
} | } |
| |
CIMValue::CIMValue(Uint16 x) |
inline void _toString(Buffer& out, Uint32 x) |
{ | { |
_rep = new CIMValueRep(); |
XmlWriter::append(out, x); |
set(x); |
|
} |
|
|
|
CIMValue::CIMValue(Sint16 x) |
|
{ |
|
_rep = new CIMValueRep(); |
|
set(x); |
|
} |
|
|
|
CIMValue::CIMValue(Uint32 x) |
|
{ |
|
_rep = new CIMValueRep(); |
|
set(x); |
|
} |
|
|
|
CIMValue::CIMValue(Sint32 x) |
|
{ |
|
_rep = new CIMValueRep(); |
|
set(x); |
|
} |
|
|
|
CIMValue::CIMValue(Uint64 x) |
|
{ |
|
_rep = new CIMValueRep(); |
|
set(x); |
|
} |
|
|
|
CIMValue::CIMValue(Sint64 x) |
|
{ |
|
_rep = new CIMValueRep(); |
|
set(x); |
|
} |
|
|
|
CIMValue::CIMValue(Real32 x) |
|
{ |
|
_rep = new CIMValueRep(); |
|
set(x); |
|
} |
|
|
|
CIMValue::CIMValue(Real64 x) |
|
{ |
|
_rep = new CIMValueRep(); |
|
set(x); |
|
} |
|
|
|
CIMValue::CIMValue(const Char16& x) |
|
{ |
|
_rep = new CIMValueRep(); |
|
set(x); |
|
} |
|
|
|
CIMValue::CIMValue(const String& x) |
|
{ |
|
_rep = new CIMValueRep(); |
|
set(x); |
|
} |
|
|
|
CIMValue::CIMValue(const CIMDateTime& x) |
|
{ |
|
_rep = new CIMValueRep(); |
|
set(x); |
|
} |
|
|
|
CIMValue::CIMValue(const CIMObjectPath& x) |
|
{ |
|
_rep = new CIMValueRep(); |
|
set(x); |
|
} | } |
| |
CIMValue::CIMValue(const CIMObject& x) |
inline void _toString(Buffer& out, Sint32 x) |
{ | { |
_rep = new CIMValueRep(); |
XmlWriter::append(out, x); |
set(x); |
|
} | } |
| |
CIMValue::CIMValue(const Array<Boolean>& x) |
inline void _toString(Buffer& out, Uint64 x) |
{ | { |
_rep = new CIMValueRep(); |
XmlWriter::append(out, x); |
set(x); |
|
} |
|
|
|
CIMValue::CIMValue(const Array<Uint8>& x) |
|
{ |
|
_rep = new CIMValueRep(); |
|
set(x); |
|
} | } |
| |
CIMValue::CIMValue(const Array<Sint8>& x) |
inline void _toString(Buffer& out, Sint64 x) |
{ | { |
_rep = new CIMValueRep(); |
XmlWriter::append(out, x); |
set(x); |
|
} | } |
| |
CIMValue::CIMValue(const Array<Uint16>& x) |
inline void _toString(Buffer& out, Real32 x) |
{ | { |
_rep = new CIMValueRep(); |
XmlWriter::append(out, Real64(x)); |
set(x); |
|
} | } |
| |
CIMValue::CIMValue(const Array<Sint16>& x) |
inline void _toString(Buffer& out, Real64 x) |
{ | { |
_rep = new CIMValueRep(); |
XmlWriter::append(out, x); |
set(x); |
|
} | } |
| |
CIMValue::CIMValue(const Array<Uint32>& x) |
inline void _toString(Buffer& out, Char16 x) |
{ | { |
_rep = new CIMValueRep(); |
// We need to convert the Char16 to UTF8 then append the UTF8 |
set(x); |
// character into the array. |
} |
// NOTE: The UTF8 character could be several bytes long. |
|
// WARNING: This function will put in replacement character for |
|
// all characters that have surogate pairs. |
| |
CIMValue::CIMValue(const Array<Sint32>& x) |
char str[6]; |
{ |
memset(str,0x00,sizeof(str)); |
_rep = new CIMValueRep(); |
char* charIN = (char *)&x; |
set(x); |
|
} |
|
| |
CIMValue::CIMValue(const Array<Uint64>& x) |
const Uint16 *strsrc = (Uint16 *)charIN; |
{ |
Uint16 *endsrc = (Uint16 *)&charIN[1]; |
_rep = new CIMValueRep(); |
|
set(x); |
|
} |
|
| |
CIMValue::CIMValue(const Array<Sint64>& x) |
Uint8 *strtgt = (Uint8 *)str; |
{ |
Uint8 *endtgt = (Uint8 *)&str[5]; |
_rep = new CIMValueRep(); |
|
set(x); |
|
} |
|
| |
CIMValue::CIMValue(const Array<Real32>& x) |
UTF16toUTF8(&strsrc, endsrc, &strtgt, endtgt); |
{ |
out.append(str, UTF_8_COUNT_TRAIL_BYTES(str[0]) +1); |
_rep = new CIMValueRep(); |
|
set(x); |
|
} | } |
| |
CIMValue::CIMValue(const Array<Real64>& x) |
inline void _toString(Buffer& out, const String& x) |
{ | { |
_rep = new CIMValueRep(); |
out << x; |
set(x); |
|
} | } |
| |
CIMValue::CIMValue(const Array<Char16>& x) |
inline void _toString(Buffer& out, const CIMDateTime& x) |
{ | { |
_rep = new CIMValueRep(); |
out << x.toString(); |
set(x); |
|
} | } |
| |
CIMValue::CIMValue(const Array<String>& x) |
inline void _toString(Buffer& out, const CIMObjectPath& x) |
{ | { |
_rep = new CIMValueRep(); |
out << x.toString(); |
set(x); |
|
} | } |
| |
CIMValue::CIMValue(const Array<CIMDateTime>& x) |
inline void _toString(Buffer& out, const CIMObject& x) |
{ | { |
_rep = new CIMValueRep(); |
out << x.toString(); |
set(x); |
|
} | } |
| |
CIMValue::CIMValue(const Array<CIMObjectPath>& x) |
template<class T> |
|
void _toString(Buffer& out, const T* p, Uint32 size) |
{ | { |
_rep = new CIMValueRep(); |
while (size--) |
set(x); |
|
} |
|
|
|
CIMValue::CIMValue(const Array<CIMObject>& x) |
|
{ | { |
_rep = new CIMValueRep(); |
_toString(out, *p++); |
set(x); |
out.append(' '); |
} | } |
|
|
CIMValue::CIMValue(const CIMValue& x) |
|
{ |
|
_rep = new CIMValueRep(); |
|
assign(x); |
|
} | } |
| |
CIMValue::~CIMValue() |
//============================================================================== |
{ |
// |
clear(); |
// CIMValueRep |
delete _rep; |
// |
} |
//============================================================================== |
| |
CIMValue& CIMValue::operator=(const CIMValue& x) |
CIMValueRep CIMValueRep::_emptyRep((int*)0); |
{ |
|
assign(x); |
|
return *this; |
|
} |
|
| |
void CIMValue::assign(const CIMValue& x) |
void CIMValueRep::release() |
{ | { |
if (this == &x) |
if (isArray) |
return; |
|
|
|
clear(); |
|
|
|
_rep->_type = x._rep->_type; |
|
_rep->_isArray = x._rep->_isArray; |
|
_rep->_isNull = x._rep->_isNull; |
|
|
|
if (_rep->_isArray) |
|
{ | { |
switch (_rep->_type) |
switch (type) |
{ | { |
case CIMTYPE_BOOLEAN: | case CIMTYPE_BOOLEAN: |
_rep->_u._booleanArray = |
CIMValueType<Boolean>::destructArray(this); |
new Array<Boolean>(*(x._rep->_u._booleanArray)); |
|
break; | break; |
| |
case CIMTYPE_UINT8: | case CIMTYPE_UINT8: |
_rep->_u._uint8Array = |
CIMValueType<Uint8>::destructArray(this); |
new Array<Uint8>(*(x._rep->_u._uint8Array)); |
|
break; | break; |
| |
case CIMTYPE_SINT8: | case CIMTYPE_SINT8: |
_rep->_u._sint8Array = |
CIMValueType<Sint8>::destructArray(this); |
new Array<Sint8>(*(x._rep->_u._sint8Array)); |
|
break; | break; |
| |
case CIMTYPE_UINT16: | case CIMTYPE_UINT16: |
_rep->_u._uint16Array = |
CIMValueType<Uint16>::destructArray(this); |
new Array<Uint16>(*(x._rep->_u._uint16Array)); |
|
break; | break; |
| |
case CIMTYPE_SINT16: | case CIMTYPE_SINT16: |
_rep->_u._sint16Array = |
CIMValueType<Sint16>::destructArray(this); |
new Array<Sint16>(*(x._rep->_u._sint16Array)); |
|
break; | break; |
| |
case CIMTYPE_UINT32: | case CIMTYPE_UINT32: |
_rep->_u._uint32Array = |
CIMValueType<Uint32>::destructArray(this); |
new Array<Uint32>(*(x._rep->_u._uint32Array)); |
|
break; | break; |
| |
case CIMTYPE_SINT32: | case CIMTYPE_SINT32: |
_rep->_u._sint32Array = |
CIMValueType<Sint32>::destructArray(this); |
new Array<Sint32>(*(x._rep->_u._sint32Array)); |
|
break; | break; |
| |
case CIMTYPE_UINT64: | case CIMTYPE_UINT64: |
_rep->_u._uint64Array = |
CIMValueType<Uint64>::destructArray(this); |
new Array<Uint64>(*(x._rep->_u._uint64Array)); |
|
break; | break; |
| |
case CIMTYPE_SINT64: | case CIMTYPE_SINT64: |
_rep->_u._sint64Array = |
CIMValueType<Sint64>::destructArray(this); |
new Array<Sint64>(*(x._rep->_u._sint64Array)); |
|
break; | break; |
| |
case CIMTYPE_REAL32: | case CIMTYPE_REAL32: |
_rep->_u._real32Array = |
CIMValueType<Real32>::destructArray(this); |
new Array<Real32>(*(x._rep->_u._real32Array)); |
|
break; | break; |
| |
case CIMTYPE_REAL64: | case CIMTYPE_REAL64: |
_rep->_u._real64Array = |
CIMValueType<Real64>::destructArray(this); |
new Array<Real64>(*(x._rep->_u._real64Array)); |
|
break; | break; |
| |
case CIMTYPE_CHAR16: | case CIMTYPE_CHAR16: |
_rep->_u._char16Array = |
CIMValueType<Char16>::destructArray(this); |
new Array<Char16>(*(x._rep->_u._char16Array)); |
|
break; | break; |
| |
case CIMTYPE_STRING: | case CIMTYPE_STRING: |
_rep->_u._stringArray = |
CIMValueType<String>::destructArray(this); |
new Array<String>(*(x._rep->_u._stringArray)); |
|
break; | break; |
| |
case CIMTYPE_DATETIME: | case CIMTYPE_DATETIME: |
_rep->_u._dateTimeArray = |
CIMValueType<CIMDateTime>::destructArray(this); |
new Array<CIMDateTime>(*(x._rep->_u._dateTimeArray)); |
|
break; | break; |
| |
case CIMTYPE_REFERENCE: | case CIMTYPE_REFERENCE: |
_rep->_u._referenceArray = |
CIMValueType<CIMObjectPath>::destructArray(this); |
new Array<CIMObjectPath>(*(x._rep->_u._referenceArray)); |
|
break; | break; |
| |
case CIMTYPE_OBJECT: | case CIMTYPE_OBJECT: |
_rep->_u._cimobjectArray = |
CIMValueType<CIMObject>::destructArray(this); |
new Array<CIMObject>(*(x._rep->_u._cimobjectArray)); |
|
break; | break; |
|
|
default: |
|
PEGASUS_ASSERT(false); |
|
} | } |
} | } |
else | else |
{ | { |
switch (_rep->_type) |
switch (type) |
{ | { |
case CIMTYPE_BOOLEAN: | case CIMTYPE_BOOLEAN: |
_rep->_u._booleanValue = x._rep->_u._booleanValue; |
|
break; |
|
|
|
case CIMTYPE_UINT8: | case CIMTYPE_UINT8: |
_rep->_u._uint8Value = x._rep->_u._uint8Value; |
|
break; |
|
|
|
case CIMTYPE_SINT8: | case CIMTYPE_SINT8: |
_rep->_u._sint8Value = x._rep->_u._sint8Value; |
|
break; |
|
|
|
case CIMTYPE_UINT16: | case CIMTYPE_UINT16: |
_rep->_u._uint16Value = x._rep->_u._uint16Value; |
|
break; |
|
|
|
case CIMTYPE_SINT16: | case CIMTYPE_SINT16: |
_rep->_u._sint16Value = x._rep->_u._sint16Value; |
|
break; |
|
|
|
case CIMTYPE_UINT32: | case CIMTYPE_UINT32: |
_rep->_u._uint32Value = x._rep->_u._uint32Value; |
|
break; |
|
|
|
case CIMTYPE_SINT32: | case CIMTYPE_SINT32: |
_rep->_u._sint32Value = x._rep->_u._sint32Value; |
|
break; |
|
|
|
case CIMTYPE_UINT64: | case CIMTYPE_UINT64: |
_rep->_u._uint64Value = x._rep->_u._uint64Value; |
|
break; |
|
|
|
case CIMTYPE_SINT64: | case CIMTYPE_SINT64: |
_rep->_u._sint64Value = x._rep->_u._sint64Value; |
|
break; |
|
|
|
case CIMTYPE_REAL32: | case CIMTYPE_REAL32: |
_rep->_u._real32Value = x._rep->_u._real32Value; |
|
break; |
|
|
|
case CIMTYPE_REAL64: | case CIMTYPE_REAL64: |
_rep->_u._real64Value = x._rep->_u._real64Value; |
|
break; |
|
|
|
case CIMTYPE_CHAR16: | case CIMTYPE_CHAR16: |
_rep->_u._char16Value = x._rep->_u._char16Value; |
|
break; | break; |
| |
case CIMTYPE_STRING: | case CIMTYPE_STRING: |
_rep->_u._stringValue = new String(*(x._rep->_u._stringValue)); |
CIMValueType<String>::destruct(this); |
break; | break; |
| |
case CIMTYPE_DATETIME: | case CIMTYPE_DATETIME: |
_rep->_u._dateTimeValue = |
CIMValueType<CIMDateTime>::destruct(this); |
new CIMDateTime(*(x._rep->_u._dateTimeValue)); |
|
break; | break; |
| |
case CIMTYPE_REFERENCE: | case CIMTYPE_REFERENCE: |
_rep->_u._referenceValue = |
CIMValueType<CIMObjectPath>::destruct(this); |
new CIMObjectPath(*(x._rep->_u._referenceValue)); |
|
break; | break; |
| |
case CIMTYPE_OBJECT: | case CIMTYPE_OBJECT: |
_rep->_u._cimobjectValue = |
CIMValueType<CIMObject>::destruct(this); |
new CIMObject(x._rep->_u._cimobjectValue->clone()); |
|
break; | break; |
|
|
// Should never get here. testing complete enum |
|
default: |
|
PEGASUS_ASSERT(false); |
|
} | } |
} | } |
} | } |
| |
void CIMValue::clear() |
//============================================================================== |
|
// |
|
// CIMValue |
|
// |
|
//============================================================================== |
|
|
|
static inline void _release(CIMValueRep*& rep) |
{ | { |
if (_rep->_isArray) |
if (rep->refs.get() == 1) |
|
rep->release(); |
|
else |
|
{ |
|
CIMValueRep::unref(rep); |
|
rep = new CIMValueRep; |
|
} |
|
} |
|
|
|
CIMValue::CIMValue(CIMType type, Boolean isArray, Uint32 arraySize) |
{ | { |
switch (_rep->_type) |
_rep = new CIMValueRep; |
|
|
|
switch (type) |
{ | { |
case CIMTYPE_BOOLEAN: | case CIMTYPE_BOOLEAN: |
delete _rep->_u._booleanArray; |
CIMValueType<Boolean>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_UINT8: | case CIMTYPE_UINT8: |
delete _rep->_u._uint8Array; |
CIMValueType<Uint8>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_SINT8: | case CIMTYPE_SINT8: |
delete _rep->_u._sint8Array; |
CIMValueType<Sint8>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_UINT16: | case CIMTYPE_UINT16: |
delete _rep->_u._uint16Array; |
CIMValueType<Uint16>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_SINT16: | case CIMTYPE_SINT16: |
delete _rep->_u._sint16Array; |
CIMValueType<Sint16>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_UINT32: | case CIMTYPE_UINT32: |
delete _rep->_u._uint32Array; |
CIMValueType<Uint32>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_SINT32: | case CIMTYPE_SINT32: |
delete _rep->_u._sint32Array; |
CIMValueType<Sint32>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_UINT64: | case CIMTYPE_UINT64: |
delete _rep->_u._uint64Array; |
CIMValueType<Uint64>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_SINT64: | case CIMTYPE_SINT64: |
delete _rep->_u._sint64Array; |
CIMValueType<Sint64>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_REAL32: | case CIMTYPE_REAL32: |
delete _rep->_u._real32Array; |
CIMValueType<Real32>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_REAL64: | case CIMTYPE_REAL64: |
delete _rep->_u._real64Array; |
CIMValueType<Real64>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_CHAR16: | case CIMTYPE_CHAR16: |
delete _rep->_u._char16Array; |
CIMValueType<Char16>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_STRING: | case CIMTYPE_STRING: |
delete _rep->_u._stringArray; |
CIMValueType<String>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_DATETIME: | case CIMTYPE_DATETIME: |
delete _rep->_u._dateTimeArray; |
CIMValueType<CIMDateTime>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_REFERENCE: | case CIMTYPE_REFERENCE: |
delete _rep->_u._referenceArray; |
CIMValueType<CIMObjectPath>::setNull(_rep, type, isArray,arraySize); |
break; | break; |
| |
case CIMTYPE_OBJECT: | case CIMTYPE_OBJECT: |
delete _rep->_u._cimobjectArray; |
CIMValueType<CIMObject>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
default: | default: |
PEGASUS_ASSERT(false); |
PEGASUS_ASSERT(0); |
} | } |
} | } |
else |
|
|
CIMValue::CIMValue(Boolean x) |
{ | { |
switch (_rep->_type) |
_rep = new CIMValueRep; |
|
CIMValueType<Boolean>::set(_rep, x); |
|
} |
|
|
|
CIMValue::CIMValue(Uint8 x) |
{ | { |
case CIMTYPE_BOOLEAN: |
_rep = new CIMValueRep; |
case CIMTYPE_UINT8: |
CIMValueType<Uint8>::set(_rep, x); |
case CIMTYPE_SINT8: |
} |
case CIMTYPE_UINT16: |
|
case CIMTYPE_SINT16: |
|
case CIMTYPE_UINT32: |
|
case CIMTYPE_SINT32: |
|
case CIMTYPE_UINT64: |
|
case CIMTYPE_SINT64: |
|
case CIMTYPE_REAL32: |
|
case CIMTYPE_REAL64: |
|
case CIMTYPE_CHAR16: |
|
break; |
|
| |
case CIMTYPE_STRING: |
CIMValue::CIMValue(Sint8 x) |
delete _rep->_u._stringValue; |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Sint8>::set(_rep, x); |
|
} |
| |
case CIMTYPE_DATETIME: |
CIMValue::CIMValue(Uint16 x) |
delete _rep->_u._dateTimeValue; |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Uint16>::set(_rep, x); |
|
} |
| |
case CIMTYPE_REFERENCE: |
CIMValue::CIMValue(Sint16 x) |
delete _rep->_u._referenceValue; |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Sint16>::set(_rep, x); |
|
} |
| |
case CIMTYPE_OBJECT: |
CIMValue::CIMValue(Uint32 x) |
delete _rep->_u._cimobjectValue; |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Uint32>::set(_rep, x); |
|
} |
| |
default: |
CIMValue::CIMValue(Sint32 x) |
PEGASUS_ASSERT(false); |
{ |
|
_rep = new CIMValueRep; |
|
CIMValueType<Sint32>::set(_rep, x); |
} | } |
|
|
|
CIMValue::CIMValue(Uint64 x) |
|
{ |
|
_rep = new CIMValueRep; |
|
CIMValueType<Uint64>::set(_rep, x); |
} | } |
| |
_rep->reset(); |
CIMValue::CIMValue(Sint64 x) |
|
{ |
|
_rep = new CIMValueRep; |
|
CIMValueType<Sint64>::set(_rep, x); |
} | } |
| |
Boolean CIMValue::typeCompatible(const CIMValue& x) const |
CIMValue::CIMValue(Real32 x) |
{ | { |
return (_rep->_type == x._rep->_type && |
_rep = new CIMValueRep; |
_rep->_isArray == x._rep->_isArray); |
CIMValueType<Real32>::set(_rep, x); |
// getArraySize() == x.getArraySize()); |
|
} | } |
| |
Boolean CIMValue::isArray() const |
CIMValue::CIMValue(Real64 x) |
{ | { |
return _rep->_isArray; |
_rep = new CIMValueRep; |
|
CIMValueType<Real64>::set(_rep, x); |
} | } |
| |
Boolean CIMValue::isNull() const |
CIMValue::CIMValue(const Char16& x) |
{ | { |
return _rep->_isNull; |
_rep = new CIMValueRep; |
|
CIMValueType<Char16>::set(_rep, x); |
} | } |
| |
Uint32 CIMValue::getArraySize() const |
CIMValue::CIMValue(const String& x) |
{ | { |
if (!_rep->_isArray) |
_rep = new CIMValueRep; |
return 0; |
CIMValueType<String>::set(_rep, x); |
|
} |
| |
switch (_rep->_type) |
CIMValue::CIMValue(const CIMDateTime& x) |
{ | { |
case CIMTYPE_BOOLEAN: |
_rep = new CIMValueRep; |
return _rep->_u._booleanArray->size(); |
CIMValueType<CIMDateTime>::set(_rep, x); |
break; |
} |
| |
case CIMTYPE_UINT8: |
CIMValue::CIMValue(const CIMObjectPath& x) |
return _rep->_u._uint8Array->size(); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<CIMObjectPath>::set(_rep, x); |
|
} |
| |
case CIMTYPE_SINT8: |
CIMValue::CIMValue(const CIMObject& x) |
return _rep->_u._sint8Array->size(); |
{ |
break; |
if (x.isUninitialized()) |
|
{ |
|
// Bug 3373, throw exception if uninitialized object is passed to set(). |
|
throw UninitializedObjectException(); |
|
} |
| |
case CIMTYPE_UINT16: |
_rep = new CIMValueRep; |
return _rep->_u._uint16Array->size(); |
CIMValueType<CIMObject>::set(_rep, x.clone()); |
break; |
} |
| |
case CIMTYPE_SINT16: |
CIMValue::CIMValue(const Array<Boolean>& x) |
return _rep->_u._sint16Array->size(); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Boolean>::setArray(_rep, x); |
|
} |
| |
case CIMTYPE_UINT32: |
CIMValue::CIMValue(const Array<Uint8>& x) |
return _rep->_u._uint32Array->size(); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Uint8>::setArray(_rep, x); |
|
} |
| |
case CIMTYPE_SINT32: |
CIMValue::CIMValue(const Array<Sint8>& x) |
return _rep->_u._sint32Array->size(); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Sint8>::setArray(_rep, x); |
|
} |
| |
case CIMTYPE_UINT64: |
CIMValue::CIMValue(const Array<Uint16>& x) |
return _rep->_u._uint64Array->size(); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Uint16>::setArray(_rep, x); |
|
} |
| |
case CIMTYPE_SINT64: |
CIMValue::CIMValue(const Array<Sint16>& x) |
return _rep->_u._sint64Array->size(); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Sint16>::setArray(_rep, x); |
|
} |
| |
case CIMTYPE_REAL32: |
CIMValue::CIMValue(const Array<Uint32>& x) |
return _rep->_u._real32Array->size(); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Uint32>::setArray(_rep, x); |
|
} |
| |
case CIMTYPE_REAL64: |
CIMValue::CIMValue(const Array<Sint32>& x) |
return _rep->_u._real64Array->size(); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Sint32>::setArray(_rep, x); |
|
} |
| |
case CIMTYPE_CHAR16: |
CIMValue::CIMValue(const Array<Uint64>& x) |
return _rep->_u._char16Array->size(); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Uint64>::setArray(_rep, x); |
|
} |
| |
case CIMTYPE_STRING: |
CIMValue::CIMValue(const Array<Sint64>& x) |
return _rep->_u._stringArray->size(); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Sint64>::setArray(_rep, x); |
|
} |
| |
case CIMTYPE_DATETIME: |
CIMValue::CIMValue(const Array<Real32>& x) |
return _rep->_u._dateTimeArray->size(); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Real32>::setArray(_rep, x); |
|
} |
| |
case CIMTYPE_REFERENCE: |
CIMValue::CIMValue(const Array<Real64>& x) |
return _rep->_u._referenceArray->size(); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Real64>::setArray(_rep, x); |
|
} |
| |
case CIMTYPE_OBJECT: |
CIMValue::CIMValue(const Array<Char16>& x) |
return _rep->_u._cimobjectArray->size(); |
{ |
break; |
_rep = new CIMValueRep; |
|
CIMValueType<Char16>::setArray(_rep, x); |
|
} |
| |
//default: // Handled below |
CIMValue::CIMValue(const Array<String>& x) |
|
{ |
|
_rep = new CIMValueRep; |
|
CIMValueType<String>::setArray(_rep, x); |
} | } |
| |
// Unreachable! |
CIMValue::CIMValue(const Array<CIMDateTime>& x) |
PEGASUS_ASSERT(false); |
{ |
return 0; |
_rep = new CIMValueRep; |
|
CIMValueType<CIMDateTime>::setArray(_rep, x); |
} | } |
| |
CIMType CIMValue::getType() const |
CIMValue::CIMValue(const Array<CIMObjectPath>& x) |
{ | { |
return CIMType(_rep->_type); |
_rep = new CIMValueRep; |
|
CIMValueType<CIMObjectPath>::setArray(_rep, x); |
} | } |
| |
void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize) |
CIMValue::CIMValue(const Array<CIMObject>& x) |
{ | { |
clear(); |
Array<CIMObject> tmp; |
| |
if (isArray) |
for (Uint32 i = 0, n = x.size(); i < n; i++) |
{ | { |
switch (type) |
if (x[i].isUninitialized()) |
|
{ |
|
// Bug 3373, throw exception on uninitialized object. |
|
_rep = &CIMValueRep::_emptyRep; |
|
throw UninitializedObjectException(); |
|
} |
|
|
|
tmp.append(x[i].clone()); |
|
} |
|
|
|
_rep = new CIMValueRep; |
|
CIMValueType<CIMObject>::setArray(_rep, tmp); |
|
} |
|
|
|
void CIMValue::clear() |
|
{ |
|
CIMValueRep::unref(_rep); |
|
_rep = &CIMValueRep::_emptyRep; |
|
} |
|
|
|
CIMValue& CIMValue::operator=(const CIMValue& x) |
|
{ |
|
if (_rep != x._rep) |
|
{ |
|
CIMValueRep::unref(_rep); |
|
CIMValueRep::ref(_rep = x._rep); |
|
} |
|
|
|
return *this; |
|
} |
|
|
|
void CIMValue::assign(const CIMValue& x) |
|
{ |
|
if (_rep != x._rep) |
|
{ |
|
CIMValueRep::unref(_rep); |
|
CIMValueRep::ref(_rep = x._rep); |
|
} |
|
} |
|
|
|
Boolean CIMValue::typeCompatible(const CIMValue& x) const |
|
{ |
|
return (_rep->type == x._rep->type && _rep->isArray == x._rep->isArray); |
|
} |
|
|
|
Uint32 CIMValue::getArraySize() const |
|
{ |
|
if (!_rep->isArray) |
|
return 0; |
|
|
|
switch (_rep->type) |
{ | { |
case CIMTYPE_BOOLEAN: | case CIMTYPE_BOOLEAN: |
set(Array<Boolean>(arraySize)); |
return CIMValueType<Boolean>::arraySize(_rep); |
break; |
|
| |
case CIMTYPE_UINT8: | case CIMTYPE_UINT8: |
set(Array<Uint8>(arraySize)); |
return CIMValueType<Uint8>::arraySize(_rep); |
break; |
|
| |
case CIMTYPE_SINT8: | case CIMTYPE_SINT8: |
set(Array<Sint8>(arraySize)); |
return CIMValueType<Sint8>::arraySize(_rep); |
break; |
|
| |
case CIMTYPE_UINT16: | case CIMTYPE_UINT16: |
set(Array<Uint16>(arraySize)); |
return CIMValueType<Uint16>::arraySize(_rep); |
break; |
|
| |
case CIMTYPE_SINT16: | case CIMTYPE_SINT16: |
set(Array<Sint16>(arraySize)); |
return CIMValueType<Sint16>::arraySize(_rep); |
break; |
|
| |
case CIMTYPE_UINT32: | case CIMTYPE_UINT32: |
set(Array<Uint32>(arraySize)); |
return CIMValueType<Uint32>::arraySize(_rep); |
break; |
|
| |
case CIMTYPE_SINT32: | case CIMTYPE_SINT32: |
set(Array<Sint32>(arraySize)); |
return CIMValueType<Sint32>::arraySize(_rep); |
break; |
|
| |
case CIMTYPE_UINT64: | case CIMTYPE_UINT64: |
set(Array<Uint64>(arraySize)); |
return CIMValueType<Uint64>::arraySize(_rep); |
break; |
|
| |
case CIMTYPE_SINT64: | case CIMTYPE_SINT64: |
set(Array<Sint64>(arraySize)); |
return CIMValueType<Sint64>::arraySize(_rep); |
break; |
|
| |
case CIMTYPE_REAL32: | case CIMTYPE_REAL32: |
set(Array<Real32>(arraySize)); |
return CIMValueType<Real32>::arraySize(_rep); |
break; |
|
| |
case CIMTYPE_REAL64: | case CIMTYPE_REAL64: |
set(Array<Real64>(arraySize)); |
return CIMValueType<Real64>::arraySize(_rep); |
break; |
|
| |
case CIMTYPE_CHAR16: | case CIMTYPE_CHAR16: |
set(Array<Char16>(arraySize)); |
return CIMValueType<Char16>::arraySize(_rep); |
break; |
|
| |
case CIMTYPE_STRING: | case CIMTYPE_STRING: |
set(Array<String>(arraySize)); |
return CIMValueType<String>::arraySize(_rep); |
break; |
|
| |
case CIMTYPE_DATETIME: | case CIMTYPE_DATETIME: |
set(Array<CIMDateTime>(arraySize)); |
return CIMValueType<CIMDateTime>::arraySize(_rep); |
break; |
|
| |
case CIMTYPE_REFERENCE: | case CIMTYPE_REFERENCE: |
set(Array<CIMObjectPath>(arraySize)); |
return CIMValueType<CIMObjectPath>::arraySize(_rep); |
break; |
|
| |
case CIMTYPE_OBJECT: | case CIMTYPE_OBJECT: |
set(Array<CIMObject>(arraySize)); |
return CIMValueType<CIMObject>::arraySize(_rep); |
break; |
|
| |
default: | default: |
throw TypeMismatchException(); |
PEGASUS_ASSERT(0); |
} | } |
|
|
|
return 0; |
} | } |
else |
|
|
void CIMValue::setNullValue(CIMType type, Boolean isArray, Uint32 arraySize) |
{ | { |
|
// |
|
// Release any memory: |
|
// |
|
|
|
_release(_rep); |
|
|
|
// |
|
// Set the null value: |
|
// |
|
|
switch (type) | switch (type) |
{ | { |
case CIMTYPE_BOOLEAN: | case CIMTYPE_BOOLEAN: |
set(false); |
CIMValueType<Boolean>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_UINT8: | case CIMTYPE_UINT8: |
set(Uint8(0)); |
CIMValueType<Uint8>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_SINT8: | case CIMTYPE_SINT8: |
set(Sint8(0)); |
CIMValueType<Sint8>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_UINT16: | case CIMTYPE_UINT16: |
set(Uint16(0)); |
CIMValueType<Uint16>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_SINT16: | case CIMTYPE_SINT16: |
set(Sint16(0)); |
CIMValueType<Sint16>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_UINT32: | case CIMTYPE_UINT32: |
set(Uint32(0)); |
CIMValueType<Uint32>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_SINT32: | case CIMTYPE_SINT32: |
set(Sint32(0)); |
CIMValueType<Sint32>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_UINT64: | case CIMTYPE_UINT64: |
set(Uint64(0)); |
CIMValueType<Uint64>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_SINT64: | case CIMTYPE_SINT64: |
set(Sint64(0)); |
CIMValueType<Sint64>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_REAL32: | case CIMTYPE_REAL32: |
set(Real32(0.0)); |
CIMValueType<Real32>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_REAL64: | case CIMTYPE_REAL64: |
set(Real64(0.0)); |
CIMValueType<Real64>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_CHAR16: | case CIMTYPE_CHAR16: |
set(Char16(0)); |
CIMValueType<Char16>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_STRING: | case CIMTYPE_STRING: |
set(String()); |
CIMValueType<String>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_DATETIME: | case CIMTYPE_DATETIME: |
set(CIMDateTime()); |
CIMValueType<CIMDateTime>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
case CIMTYPE_REFERENCE: | case CIMTYPE_REFERENCE: |
set(CIMObjectPath()); |
CIMValueType<CIMObjectPath>::setNull(_rep, type, isArray,arraySize); |
break; | break; |
| |
case CIMTYPE_OBJECT: | case CIMTYPE_OBJECT: |
set(CIMObject()); |
CIMValueType<CIMObject>::setNull(_rep, type, isArray, arraySize); |
break; | break; |
| |
default: | default: |
throw TypeMismatchException(); |
PEGASUS_ASSERT(0); |
} |
|
} | } |
|
|
// Set the Null attribute. Note that this must be after the set |
|
// because the set functions sets the _isNull. |
|
|
|
_rep->_isNull = true; |
|
} | } |
| |
void CIMValue::set(Boolean x) | void CIMValue::set(Boolean x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._booleanValue = (Uint8)x; |
CIMValueType<Boolean>::set(_rep, x); |
_rep->_type = CIMTYPE_BOOLEAN; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(Uint8 x) | void CIMValue::set(Uint8 x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._uint8Value = x; |
CIMValueType<Uint8>::set(_rep, x); |
_rep->_type = CIMTYPE_UINT8; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(Sint8 x) | void CIMValue::set(Sint8 x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._sint8Value = x; |
CIMValueType<Sint8>::set(_rep, x); |
_rep->_type = CIMTYPE_SINT8; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(Uint16 x) | void CIMValue::set(Uint16 x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._uint16Value = x; |
CIMValueType<Uint16>::set(_rep, x); |
_rep->_type = CIMTYPE_UINT16; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(Sint16 x) | void CIMValue::set(Sint16 x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._sint16Value = x; |
CIMValueType<Sint16>::set(_rep, x); |
_rep->_type = CIMTYPE_SINT16; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(Uint32 x) | void CIMValue::set(Uint32 x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._uint32Value = x; |
CIMValueType<Uint32>::set(_rep, x); |
_rep->_type = CIMTYPE_UINT32; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(Sint32 x) | void CIMValue::set(Sint32 x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._sint32Value = x; |
CIMValueType<Sint32>::set(_rep, x); |
_rep->_type = CIMTYPE_SINT32; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(Uint64 x) | void CIMValue::set(Uint64 x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._uint64Value = x; |
CIMValueType<Uint64>::set(_rep, x); |
_rep->_type = CIMTYPE_UINT64; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(Sint64 x) | void CIMValue::set(Sint64 x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._sint64Value = x; |
CIMValueType<Sint64>::set(_rep, x); |
_rep->_type = CIMTYPE_SINT64; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(Real32 x) | void CIMValue::set(Real32 x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._real32Value = x; |
CIMValueType<Real32>::set(_rep, x); |
_rep->_type = CIMTYPE_REAL32; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(Real64 x) | void CIMValue::set(Real64 x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._real64Value = x; |
CIMValueType<Real64>::set(_rep, x); |
_rep->_type = CIMTYPE_REAL64; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const Char16& x) | void CIMValue::set(const Char16& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._char16Value = x; |
CIMValueType<Char16>::set(_rep, x); |
_rep->_type = CIMTYPE_CHAR16; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const String& x) | void CIMValue::set(const String& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._stringValue = new String(x); |
CIMValueType<String>::set(_rep, x); |
_rep->_type = CIMTYPE_STRING; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const CIMDateTime& x) | void CIMValue::set(const CIMDateTime& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._dateTimeValue = new CIMDateTime(x); |
CIMValueType<CIMDateTime>::set(_rep, x); |
_rep->_type = CIMTYPE_DATETIME; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const CIMObjectPath& x) | void CIMValue::set(const CIMObjectPath& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._referenceValue = new CIMObjectPath(x); |
CIMValueType<CIMObjectPath>::set(_rep, x); |
_rep->_type = CIMTYPE_REFERENCE; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const CIMObject& x) | void CIMValue::set(const CIMObject& x) |
{ | { |
clear(); |
if (x.isUninitialized()) |
if (x.isUninitialized()) { |
{ |
// Don't need to clone since null CIMObjects aren't shared when created. |
// Bug 3373, throw exception on uninitialized object. |
// Doesn't work anyway, clone() throws an exception if null. |
throw UninitializedObjectException(); |
_rep->_u._cimobjectValue = new CIMObject(x); |
|
} |
|
else { |
|
_rep->_u._cimobjectValue = new CIMObject(x.clone()); |
|
} | } |
_rep->_type = CIMTYPE_OBJECT; |
|
_rep->_isNull = false; |
_release(_rep); |
|
CIMValueType<CIMObject>::set(_rep, x.clone()); |
} | } |
| |
void CIMValue::set(const Array<Boolean>& x) | void CIMValue::set(const Array<Boolean>& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._booleanArray = new Array<Boolean>(x); |
CIMValueType<Boolean>::setArray(_rep, x); |
_rep->_type = CIMTYPE_BOOLEAN; |
|
_rep->_isArray = true; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const Array<Uint8>& x) | void CIMValue::set(const Array<Uint8>& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._uint8Array = new Array<Uint8>(x); |
CIMValueType<Uint8>::setArray(_rep, x); |
_rep->_type = CIMTYPE_UINT8; |
|
_rep->_isArray = true; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const Array<Sint8>& x) | void CIMValue::set(const Array<Sint8>& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._sint8Array = new Array<Sint8>(x); |
CIMValueType<Sint8>::setArray(_rep, x); |
_rep->_type = CIMTYPE_SINT8; |
|
_rep->_isArray = true; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const Array<Uint16>& x) | void CIMValue::set(const Array<Uint16>& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._uint16Array = new Array<Uint16>(x); |
CIMValueType<Uint16>::setArray(_rep, x); |
_rep->_type = CIMTYPE_UINT16; |
|
_rep->_isArray = true; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const Array<Sint16>& x) | void CIMValue::set(const Array<Sint16>& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._sint16Array = new Array<Sint16>(x); |
CIMValueType<Sint16>::setArray(_rep, x); |
_rep->_type = CIMTYPE_SINT16; |
|
_rep->_isArray = true; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const Array<Uint32>& x) | void CIMValue::set(const Array<Uint32>& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._uint32Array = new Array<Uint32>(x); |
CIMValueType<Uint32>::setArray(_rep, x); |
_rep->_type = CIMTYPE_UINT32; |
|
_rep->_isArray = true; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const Array<Sint32>& x) | void CIMValue::set(const Array<Sint32>& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._sint32Array = new Array<Sint32>(x); |
CIMValueType<Sint32>::setArray(_rep, x); |
_rep->_type = CIMTYPE_SINT32; |
|
_rep->_isArray = true; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const Array<Uint64>& x) | void CIMValue::set(const Array<Uint64>& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._uint64Array = new Array<Uint64>(x); |
CIMValueType<Uint64>::setArray(_rep, x); |
_rep->_type = CIMTYPE_UINT64; |
|
_rep->_isArray = true; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const Array<Sint64>& x) | void CIMValue::set(const Array<Sint64>& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._sint64Array = new Array<Sint64>(x); |
CIMValueType<Sint64>::setArray(_rep, x); |
_rep->_type = CIMTYPE_SINT64; |
|
_rep->_isArray = true; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const Array<Real32>& x) | void CIMValue::set(const Array<Real32>& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._real32Array = new Array<Real32>(x); |
CIMValueType<Real32>::setArray(_rep, x); |
_rep->_type = CIMTYPE_REAL32; |
|
_rep->_isArray = true; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const Array<Real64>& x) | void CIMValue::set(const Array<Real64>& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._real64Array = new Array<Real64>(x); |
CIMValueType<Real64>::setArray(_rep, x); |
_rep->_type = CIMTYPE_REAL64; |
|
_rep->_isArray = true; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const Array<Char16>& x) | void CIMValue::set(const Array<Char16>& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._char16Array = new Array<Char16>(x); |
CIMValueType<Char16>::setArray(_rep, x); |
_rep->_type = CIMTYPE_CHAR16; |
|
_rep->_isArray = true; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const Array<String>& x) | void CIMValue::set(const Array<String>& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._stringArray = new Array<String>(x); |
CIMValueType<String>::setArray(_rep, x); |
_rep->_type = CIMTYPE_STRING; |
|
_rep->_isArray = true; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const Array<CIMDateTime>& x) | void CIMValue::set(const Array<CIMDateTime>& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._dateTimeArray = new Array<CIMDateTime>(x); |
CIMValueType<CIMDateTime>::setArray(_rep, x); |
_rep->_type = CIMTYPE_DATETIME; |
|
_rep->_isArray = true; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const Array<CIMObjectPath>& x) | void CIMValue::set(const Array<CIMObjectPath>& x) |
{ | { |
clear(); |
_release(_rep); |
_rep->_u._referenceArray = new Array<CIMObjectPath>(x); |
CIMValueType<CIMObjectPath>::setArray(_rep, x); |
_rep->_type = CIMTYPE_REFERENCE; |
|
_rep->_isArray = true; |
|
_rep->_isNull = false; |
|
} | } |
| |
void CIMValue::set(const Array<CIMObject>& x) |
void CIMValue::set(const Array<CIMObject>& a) |
{ |
{ |
clear(); |
Array<CIMObject> tmp; |
_rep->_u._cimobjectArray = new Array<CIMObject>(x); |
|
_rep->_type = CIMTYPE_OBJECT; |
for (Uint32 i = 0, n = a.size(); i < n; i++) |
_rep->_isArray = true; |
{ |
_rep->_isNull = false; |
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::get(Boolean& x) const | void CIMValue::get(Boolean& x) const |
{ | { |
if (_rep->_type != CIMTYPE_BOOLEAN || _rep->_isArray) |
if (_rep->type != CIMTYPE_BOOLEAN || _rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = _rep->_u._booleanValue != 0; |
x = CIMValueType<Boolean>::ref(_rep); |
} | } |
| |
void CIMValue::get(Uint8& x) const | void CIMValue::get(Uint8& x) const |
{ | { |
if (_rep->_type != CIMTYPE_UINT8 || _rep->_isArray) |
if (_rep->type != CIMTYPE_UINT8 || _rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = _rep->_u._uint8Value; |
x = CIMValueType<Uint8>::ref(_rep); |
} | } |
| |
void CIMValue::get(Sint8& x) const | void CIMValue::get(Sint8& x) const |
{ | { |
if (_rep->_type != CIMTYPE_SINT8 || _rep->_isArray) |
if (_rep->type != CIMTYPE_SINT8 || _rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = _rep->_u._sint8Value; |
x = CIMValueType<Sint8>::ref(_rep); |
} | } |
| |
void CIMValue::get(Uint16& x) const | void CIMValue::get(Uint16& x) const |
{ | { |
if (_rep->_type != CIMTYPE_UINT16 || _rep->_isArray) |
if (_rep->type != CIMTYPE_UINT16 || _rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = _rep->_u._uint16Value; |
x = CIMValueType<Uint16>::ref(_rep); |
} | } |
| |
void CIMValue::get(Sint16& x) const | void CIMValue::get(Sint16& x) const |
{ | { |
if (_rep->_type != CIMTYPE_SINT16 || _rep->_isArray) |
if (_rep->type != CIMTYPE_SINT16 || _rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = _rep->_u._sint16Value; |
x = CIMValueType<Sint16>::ref(_rep); |
} | } |
| |
|
|
void CIMValue::get(Uint32& x) const | void CIMValue::get(Uint32& x) const |
{ | { |
if (_rep->_type != CIMTYPE_UINT32 || _rep->_isArray) |
if (_rep->type != CIMTYPE_UINT32 || _rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = _rep->_u._uint32Value; |
x = CIMValueType<Uint32>::ref(_rep); |
} | } |
| |
void CIMValue::get(Sint32& x) const | void CIMValue::get(Sint32& x) const |
{ | { |
if (_rep->_type != CIMTYPE_SINT32 || _rep->_isArray) |
if (_rep->type != CIMTYPE_SINT32 || _rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = _rep->_u._sint32Value; |
x = CIMValueType<Sint32>::ref(_rep); |
} | } |
| |
void CIMValue::get(Uint64& x) const | void CIMValue::get(Uint64& x) const |
{ | { |
if (_rep->_type != CIMTYPE_UINT64 || _rep->_isArray) |
if (_rep->type != CIMTYPE_UINT64 || _rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = _rep->_u._uint64Value; |
x = CIMValueType<Uint64>::ref(_rep); |
} | } |
| |
void CIMValue::get(Sint64& x) const | void CIMValue::get(Sint64& x) const |
{ | { |
if (_rep->_type != CIMTYPE_SINT64 || _rep->_isArray) |
if (_rep->type != CIMTYPE_SINT64 || _rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = _rep->_u._sint64Value; |
x = CIMValueType<Sint64>::ref(_rep); |
} | } |
| |
void CIMValue::get(Real32& x) const | void CIMValue::get(Real32& x) const |
{ | { |
if (_rep->_type != CIMTYPE_REAL32 || _rep->_isArray) |
if (_rep->type != CIMTYPE_REAL32 || _rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = _rep->_u._real32Value; |
x = CIMValueType<Real32>::ref(_rep); |
} | } |
| |
void CIMValue::get(Real64& x) const | void CIMValue::get(Real64& x) const |
{ | { |
if (_rep->_type != CIMTYPE_REAL64 || _rep->_isArray) |
if (_rep->type != CIMTYPE_REAL64 || _rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = _rep->_u._real64Value; |
x = CIMValueType<Real64>::ref(_rep); |
} | } |
| |
void CIMValue::get(Char16& x) const | void CIMValue::get(Char16& x) const |
{ | { |
if (_rep->_type != CIMTYPE_CHAR16 || _rep->_isArray) |
if (_rep->type != CIMTYPE_CHAR16 || _rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = _rep->_u._char16Value; |
x = CIMValueType<Char16>::ref(_rep); |
} | } |
| |
void CIMValue::get(String& x) const | void CIMValue::get(String& x) const |
{ | { |
if (_rep->_type != CIMTYPE_STRING || _rep->_isArray) |
if (_rep->type != CIMTYPE_STRING || _rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._stringValue; |
x = CIMValueType<String>::ref(_rep); |
} | } |
| |
void CIMValue::get(CIMDateTime& x) const | void CIMValue::get(CIMDateTime& x) const |
{ | { |
if (_rep->_type != CIMTYPE_DATETIME || _rep->_isArray) |
if (_rep->type != CIMTYPE_DATETIME || _rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._dateTimeValue; |
x = CIMValueType<CIMDateTime>::ref(_rep); |
} | } |
| |
void CIMValue::get(CIMObjectPath& x) const | void CIMValue::get(CIMObjectPath& x) const |
{ | { |
if (_rep->_type != CIMTYPE_REFERENCE || _rep->_isArray) |
if (_rep->type != CIMTYPE_REFERENCE || _rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._referenceValue; |
x = CIMValueType<CIMObjectPath>::ref(_rep); |
} | } |
| |
void CIMValue::get(CIMObject& x) const | void CIMValue::get(CIMObject& x) const |
{ | { |
if (_rep->_type != CIMTYPE_OBJECT || _rep->_isArray) |
if (_rep->type != CIMTYPE_OBJECT || _rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._cimobjectValue; |
{ |
|
if (_rep->refs.get() != 1) |
|
{ |
|
// We have to make 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. |
|
|
|
CIMObject tmp = CIMValueType<CIMObject>::ref(_rep); |
|
((CIMValue*)this)->set(tmp); |
|
} |
|
|
|
x = CIMValueType<CIMObject>::ref(_rep); |
|
} |
} | } |
| |
void CIMValue::get(Array<Boolean>& x) const | void CIMValue::get(Array<Boolean>& x) const |
{ | { |
if (_rep->_type != CIMTYPE_BOOLEAN || !_rep->_isArray) |
if (_rep->type != CIMTYPE_BOOLEAN || !_rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._booleanArray; |
x = CIMValueType<Boolean>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Uint8>& x) const | void CIMValue::get(Array<Uint8>& x) const |
{ | { |
if (_rep->_type != CIMTYPE_UINT8 || !_rep->_isArray) |
if (_rep->type != CIMTYPE_UINT8 || !_rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._uint8Array; |
x = CIMValueType<Uint8>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Sint8>& x) const | void CIMValue::get(Array<Sint8>& x) const |
{ | { |
if (_rep->_type != CIMTYPE_SINT8 || !_rep->_isArray) |
if (_rep->type != CIMTYPE_SINT8 || !_rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._sint8Array; |
x = CIMValueType<Sint8>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Uint16>& x) const | void CIMValue::get(Array<Uint16>& x) const |
{ | { |
if (_rep->_type != CIMTYPE_UINT16 || !_rep->_isArray) |
if (_rep->type != CIMTYPE_UINT16 || !_rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._uint16Array; |
x = CIMValueType<Uint16>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Sint16>& x) const | void CIMValue::get(Array<Sint16>& x) const |
{ | { |
if (_rep->_type != CIMTYPE_SINT16 || !_rep->_isArray) |
if (_rep->type != CIMTYPE_SINT16 || !_rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._sint16Array; |
x = CIMValueType<Sint16>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Uint32>& x) const | void CIMValue::get(Array<Uint32>& x) const |
{ | { |
if (_rep->_type != CIMTYPE_UINT32 || !_rep->_isArray) |
if (_rep->type != CIMTYPE_UINT32 || !_rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._uint32Array; |
x = CIMValueType<Uint32>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Sint32>& x) const | void CIMValue::get(Array<Sint32>& x) const |
{ | { |
if (_rep->_type != CIMTYPE_SINT32 || !_rep->_isArray) |
if (_rep->type != CIMTYPE_SINT32 || !_rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._sint32Array; |
x = CIMValueType<Sint32>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Uint64>& x) const | void CIMValue::get(Array<Uint64>& x) const |
{ | { |
if (_rep->_type != CIMTYPE_UINT64 || !_rep->_isArray) |
if (_rep->type != CIMTYPE_UINT64 || !_rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._uint64Array; |
x = CIMValueType<Uint64>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Sint64>& x) const | void CIMValue::get(Array<Sint64>& x) const |
{ | { |
if (_rep->_type != CIMTYPE_SINT64 || !_rep->_isArray) |
if (_rep->type != CIMTYPE_SINT64 || !_rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._sint64Array; |
x = CIMValueType<Sint64>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Real32>& x) const | void CIMValue::get(Array<Real32>& x) const |
{ | { |
if (_rep->_type != CIMTYPE_REAL32 || !_rep->_isArray) |
if (_rep->type != CIMTYPE_REAL32 || !_rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._real32Array; |
x = CIMValueType<Real32>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Real64>& x) const | void CIMValue::get(Array<Real64>& x) const |
{ | { |
if (_rep->_type != CIMTYPE_REAL64 || !_rep->_isArray) |
if (_rep->type != CIMTYPE_REAL64 || !_rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._real64Array; |
x = CIMValueType<Real64>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<Char16>& x) const | void CIMValue::get(Array<Char16>& x) const |
{ | { |
if (_rep->_type != CIMTYPE_CHAR16 || !_rep->_isArray) |
if (_rep->type != CIMTYPE_CHAR16 || !_rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._char16Array; |
x = CIMValueType<Char16>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<String>& x) const | void CIMValue::get(Array<String>& x) const |
{ | { |
if (_rep->_type != CIMTYPE_STRING || !_rep->_isArray) |
if (_rep->type != CIMTYPE_STRING || !_rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._stringArray; |
x = CIMValueType<String>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<CIMDateTime>& x) const | void CIMValue::get(Array<CIMDateTime>& x) const |
{ | { |
if (_rep->_type != CIMTYPE_DATETIME || !_rep->_isArray) |
if (_rep->type != CIMTYPE_DATETIME || !_rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._dateTimeArray; |
x = CIMValueType<CIMDateTime>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<CIMObjectPath>& x) const | void CIMValue::get(Array<CIMObjectPath>& x) const |
{ | { |
if (_rep->_type != CIMTYPE_REFERENCE || !_rep->_isArray) |
if (_rep->type != CIMTYPE_REFERENCE || !_rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._referenceArray; |
x = CIMValueType<CIMObjectPath>::aref(_rep); |
} | } |
| |
void CIMValue::get(Array<CIMObject>& x) const | void CIMValue::get(Array<CIMObject>& x) const |
{ | { |
if (_rep->_type != CIMTYPE_OBJECT || !_rep->_isArray) |
if (_rep->type != CIMTYPE_OBJECT || !_rep->isArray) |
throw TypeMismatchException(); | throw TypeMismatchException(); |
| |
if (!_rep->_isNull) |
if (!_rep->isNull) |
x = *_rep->_u._cimobjectArray; |
{ |
|
if (_rep->refs.get() != 1) |
|
{ |
|
// We have to make 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. |
|
Array<CIMObject> tmp = CIMValueType<CIMObject>::aref(_rep); |
|
((CIMValue*)this)->set(tmp); |
|
} |
|
|
|
x = CIMValueType<CIMObject>::aref(_rep); |
|
} |
} | } |
| |
Boolean CIMValue::equal(const CIMValue& x) const | Boolean CIMValue::equal(const CIMValue& x) const |
|
|
if (!typeCompatible(x)) | if (!typeCompatible(x)) |
return false; | return false; |
| |
if (_rep->_isNull != x._rep->_isNull) |
if (_rep->isNull != x._rep->isNull) |
return false; | return false; |
| |
if (_rep->_isArray) |
if (_rep->isArray) |
{ | { |
switch (_rep->_type) |
switch (_rep->type) |
{ | { |
case CIMTYPE_BOOLEAN: | case CIMTYPE_BOOLEAN: |
return (*_rep->_u._booleanArray) == |
return CIMValueType<Boolean>::equalArray(_rep, x._rep); |
(*x._rep->_u._booleanArray); |
|
| |
case CIMTYPE_UINT8: | case CIMTYPE_UINT8: |
return (*_rep->_u._uint8Array) == |
return CIMValueType<Uint8>::equalArray(_rep, x._rep); |
(*x._rep->_u._uint8Array); |
|
| |
case CIMTYPE_SINT8: | case CIMTYPE_SINT8: |
return (*_rep->_u._sint8Array) == |
return CIMValueType<Sint8>::equalArray(_rep, x._rep); |
(*x._rep->_u._sint8Array); |
|
| |
case CIMTYPE_UINT16: | case CIMTYPE_UINT16: |
return (*_rep->_u._uint16Array) == |
return CIMValueType<Uint16>::equalArray(_rep, x._rep); |
(*x._rep->_u._uint16Array); |
|
| |
case CIMTYPE_SINT16: | case CIMTYPE_SINT16: |
return (*_rep->_u._sint16Array) == |
return CIMValueType<Sint16>::equalArray(_rep, x._rep); |
(*x._rep->_u._sint16Array); |
|
| |
case CIMTYPE_UINT32: | case CIMTYPE_UINT32: |
return (*_rep->_u._uint32Array) == |
return CIMValueType<Uint32>::equalArray(_rep, x._rep); |
(*x._rep->_u._uint32Array); |
|
| |
case CIMTYPE_SINT32: | case CIMTYPE_SINT32: |
return (*_rep->_u._sint32Array) == |
return CIMValueType<Sint32>::equalArray(_rep, x._rep); |
(*x._rep->_u._sint32Array); |
|
| |
case CIMTYPE_UINT64: | case CIMTYPE_UINT64: |
return (*_rep->_u._uint64Array) == |
return CIMValueType<Uint64>::equalArray(_rep, x._rep); |
(*x._rep->_u._uint64Array); |
|
| |
case CIMTYPE_SINT64: | case CIMTYPE_SINT64: |
return (*_rep->_u._sint64Array) == |
return CIMValueType<Sint64>::equalArray(_rep, x._rep); |
(*x._rep->_u._sint64Array); |
|
| |
case CIMTYPE_REAL32: | case CIMTYPE_REAL32: |
return (*_rep->_u._real32Array) == |
return CIMValueType<Real32>::equalArray(_rep, x._rep); |
(*x._rep->_u._real32Array); |
|
| |
case CIMTYPE_REAL64: | case CIMTYPE_REAL64: |
return (*_rep->_u._real64Array) == |
return CIMValueType<Real64>::equalArray(_rep, x._rep); |
(*x._rep->_u._real64Array); |
|
| |
case CIMTYPE_CHAR16: | case CIMTYPE_CHAR16: |
return (*_rep->_u._char16Array) == |
return CIMValueType<Char16>::equalArray(_rep, x._rep); |
(*x._rep->_u._char16Array); |
|
| |
case CIMTYPE_STRING: | case CIMTYPE_STRING: |
return (*_rep->_u._stringArray) == |
return CIMValueType<String>::equalArray(_rep, x._rep); |
(*x._rep->_u._stringArray); |
|
| |
case CIMTYPE_DATETIME: | case CIMTYPE_DATETIME: |
return (*_rep->_u._dateTimeArray) == |
return CIMValueType<CIMDateTime>::equalArray(_rep, x._rep); |
(*x._rep->_u._dateTimeArray); |
|
| |
case CIMTYPE_REFERENCE: | case CIMTYPE_REFERENCE: |
return (*_rep->_u._referenceArray) == |
return CIMValueType<CIMObjectPath>::equalArray(_rep, x._rep); |
(*x._rep->_u._referenceArray); |
|
| |
case CIMTYPE_OBJECT: | case CIMTYPE_OBJECT: |
return (*_rep->_u._cimobjectArray) == |
return CIMValueType<CIMObject>::equalArray(_rep, x._rep); |
(*x._rep->_u._cimobjectArray); |
|
| |
default: | default: |
PEGASUS_ASSERT(false); |
PEGASUS_ASSERT(0); |
} | } |
} | } |
else | else |
{ | { |
switch (_rep->_type) |
switch (_rep->type) |
{ | { |
case CIMTYPE_BOOLEAN: | case CIMTYPE_BOOLEAN: |
return _rep->_u._booleanValue == x._rep->_u._booleanValue; |
return CIMValueType<Boolean>::equal(_rep, x._rep); |
| |
case CIMTYPE_UINT8: | case CIMTYPE_UINT8: |
return _rep->_u._uint8Value == x._rep->_u._uint8Value; |
return CIMValueType<Uint8>::equal(_rep, x._rep); |
| |
case CIMTYPE_SINT8: | case CIMTYPE_SINT8: |
return _rep->_u._sint8Value == x._rep->_u._sint8Value; |
return CIMValueType<Sint8>::equal(_rep, x._rep); |
| |
case CIMTYPE_UINT16: | case CIMTYPE_UINT16: |
return _rep->_u._uint16Value == x._rep->_u._uint16Value; |
return CIMValueType<Uint16>::equal(_rep, x._rep); |
| |
case CIMTYPE_SINT16: | case CIMTYPE_SINT16: |
return _rep->_u._sint16Value == x._rep->_u._sint16Value; |
return CIMValueType<Sint16>::equal(_rep, x._rep); |
| |
case CIMTYPE_UINT32: | case CIMTYPE_UINT32: |
return _rep->_u._uint32Value == x._rep->_u._uint32Value; |
return CIMValueType<Uint32>::equal(_rep, x._rep); |
| |
case CIMTYPE_SINT32: | case CIMTYPE_SINT32: |
return _rep->_u._sint32Value == x._rep->_u._sint32Value; |
return CIMValueType<Sint32>::equal(_rep, x._rep); |
| |
case CIMTYPE_UINT64: | case CIMTYPE_UINT64: |
return _rep->_u._uint64Value == x._rep->_u._uint64Value; |
return CIMValueType<Uint64>::equal(_rep, x._rep); |
| |
case CIMTYPE_SINT64: | case CIMTYPE_SINT64: |
return _rep->_u._sint64Value == x._rep->_u._sint64Value; |
return CIMValueType<Sint64>::equal(_rep, x._rep); |
| |
case CIMTYPE_REAL32: | case CIMTYPE_REAL32: |
return _rep->_u._real32Value == x._rep->_u._real32Value; |
return CIMValueType<Real32>::equal(_rep, x._rep); |
| |
case CIMTYPE_REAL64: | case CIMTYPE_REAL64: |
return _rep->_u._real64Value == x._rep->_u._real64Value; |
return CIMValueType<Real64>::equal(_rep, x._rep); |
| |
case CIMTYPE_CHAR16: | case CIMTYPE_CHAR16: |
return _rep->_u._char16Value == x._rep->_u._char16Value; |
return CIMValueType<Char16>::equal(_rep, x._rep); |
| |
case CIMTYPE_STRING: | case CIMTYPE_STRING: |
return String::equal(*_rep->_u._stringValue, |
return CIMValueType<String>::equal(_rep, x._rep); |
*x._rep->_u._stringValue); |
|
| |
case CIMTYPE_DATETIME: | case CIMTYPE_DATETIME: |
return *_rep->_u._dateTimeValue == *x._rep->_u._dateTimeValue; |
return CIMValueType<CIMDateTime>::equal(_rep, x._rep); |
| |
case CIMTYPE_REFERENCE: | case CIMTYPE_REFERENCE: |
return *_rep->_u._referenceValue == |
return CIMValueType<CIMObjectPath>::equal(_rep, x._rep); |
*x._rep->_u._referenceValue; |
|
| |
case CIMTYPE_OBJECT: | case CIMTYPE_OBJECT: |
return (*_rep->_u._cimobjectValue).identical((*x._rep->_u._cimobjectValue)); |
return CIMValueType<CIMObject>::ref(_rep).identical( |
|
CIMValueType<CIMObject>::ref(x._rep)); |
| |
default: | default: |
PEGASUS_ASSERT(false); |
PEGASUS_ASSERT(0); |
} | } |
} | } |
| |
// Unreachable! |
|
return false; | return false; |
} | } |
| |
String CIMValue::toString() const | String CIMValue::toString() const |
{ | { |
Array<Sint8> out; |
Buffer out; |
| |
//ATTN: Not sure what we should do with getstring for Null CIMValues | //ATTN: Not sure what we should do with getstring for Null CIMValues |
//Choice return empty string or exception out. | //Choice return empty string or exception out. |
if (_rep->_isNull) |
|
|
if (_rep->isNull) |
return String(); | return String(); |
| |
if (_rep->_isArray) |
if (_rep->isArray) |
{ | { |
switch (_rep->_type) |
switch (_rep->type) |
{ | { |
case CIMTYPE_BOOLEAN: | case CIMTYPE_BOOLEAN: |
{ | { |
Uint32 size = _rep->_u._booleanArray->size(); |
const Array<Boolean>& a = CIMValueType<Boolean>::aref(_rep); |
|
Uint32 size = a.size(); |
|
|
for (Uint32 i = 0; i < size; i++) | for (Uint32 i = 0; i < size; i++) |
{ | { |
_toString(out, Boolean(_rep->_u._booleanArray->getData()[i])); |
_toString(out, a[i]); |
out << " "; |
out.append(' '); |
} | } |
break; | break; |
} | } |
| |
case CIMTYPE_UINT8: | case CIMTYPE_UINT8: |
_toString(out, _rep->_u._uint8Array->getData(), |
{ |
_rep->_u._uint8Array->size()); |
const Array<Uint8>& a = CIMValueType<Uint8>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMTYPE_SINT8: | case CIMTYPE_SINT8: |
_toString(out, _rep->_u._sint8Array->getData(), |
{ |
_rep->_u._sint8Array->size()); |
const Array<Sint8>& a = CIMValueType<Sint8>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMTYPE_UINT16: | case CIMTYPE_UINT16: |
_toString(out, _rep->_u._uint16Array->getData(), |
{ |
_rep->_u._uint16Array->size()); |
const Array<Uint16>& a = CIMValueType<Uint16>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMTYPE_SINT16: | case CIMTYPE_SINT16: |
_toString(out, _rep->_u._sint16Array->getData(), |
{ |
_rep->_u._sint16Array->size()); |
const Array<Sint16>& a = CIMValueType<Sint16>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMTYPE_UINT32: | case CIMTYPE_UINT32: |
_toString(out, _rep->_u._uint32Array->getData(), |
{ |
_rep->_u._uint32Array->size()); |
const Array<Uint32>& a = CIMValueType<Uint32>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMTYPE_SINT32: | case CIMTYPE_SINT32: |
_toString(out, _rep->_u._sint32Array->getData(), |
{ |
_rep->_u._sint32Array->size()); |
const Array<Sint32>& a = CIMValueType<Sint32>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMTYPE_UINT64: | case CIMTYPE_UINT64: |
_toString(out, _rep->_u._uint64Array->getData(), |
{ |
_rep->_u._uint64Array->size()); |
const Array<Uint64>& a = CIMValueType<Uint64>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMTYPE_SINT64: | case CIMTYPE_SINT64: |
_toString(out, _rep->_u._sint64Array->getData(), |
{ |
_rep->_u._sint64Array->size()); |
const Array<Sint64>& a = CIMValueType<Sint64>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMTYPE_REAL32: | case CIMTYPE_REAL32: |
_toString(out, _rep->_u._real32Array->getData(), |
{ |
_rep->_u._real32Array->size()); |
const Array<Real32>& a = CIMValueType<Real32>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMTYPE_REAL64: | case CIMTYPE_REAL64: |
_toString(out, _rep->_u._real64Array->getData(), |
{ |
_rep->_u._real64Array->size()); |
const Array<Real64>& a = CIMValueType<Real64>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMTYPE_CHAR16: | case CIMTYPE_CHAR16: |
_toString(out, _rep->_u._char16Array->getData(), |
{ |
_rep->_u._char16Array->size()); |
const Array<Char16>& a = CIMValueType<Char16>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMTYPE_STRING: | case CIMTYPE_STRING: |
_toString(out, _rep->_u._stringArray->getData(), |
{ |
_rep->_u._stringArray->size()); |
const Array<String>& a = CIMValueType<String>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMTYPE_DATETIME: | case CIMTYPE_DATETIME: |
_toString(out, _rep->_u._dateTimeArray->getData(), |
{ |
_rep->_u._dateTimeArray->size()); |
const Array<CIMDateTime>& a = |
|
CIMValueType<CIMDateTime>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMTYPE_REFERENCE: | case CIMTYPE_REFERENCE: |
_toString(out, _rep->_u._referenceArray->getData(), |
{ |
_rep->_u._referenceArray->size()); |
const Array<CIMObjectPath>& a = |
|
CIMValueType<CIMObjectPath>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
case CIMTYPE_OBJECT: | case CIMTYPE_OBJECT: |
_toString(out, _rep->_u._cimobjectArray->getData(), |
{ |
_rep->_u._cimobjectArray->size()); |
const Array<CIMObject>& a = CIMValueType<CIMObject>::aref(_rep); |
|
_toString(out, a.getData(), a.size()); |
break; | break; |
|
} |
| |
default: | default: |
PEGASUS_ASSERT(false); |
PEGASUS_ASSERT(0); |
} | } |
} | } |
else | else |
{ | { |
switch (_rep->_type) |
switch (_rep->type) |
{ | { |
case CIMTYPE_BOOLEAN: | case CIMTYPE_BOOLEAN: |
_toString(out, Boolean(_rep->_u._booleanValue != 0)); |
_toString(out, CIMValueType<Boolean>::ref(_rep)); |
break; | break; |
| |
case CIMTYPE_UINT8: | case CIMTYPE_UINT8: |
_toString(out, _rep->_u._uint8Value); |
_toString(out, CIMValueType<Uint8>::ref(_rep)); |
break; | break; |
| |
case CIMTYPE_SINT8: | case CIMTYPE_SINT8: |
_toString(out, _rep->_u._sint8Value); |
_toString(out, CIMValueType<Sint8>::ref(_rep)); |
break; | break; |
| |
case CIMTYPE_UINT16: | case CIMTYPE_UINT16: |
_toString(out, _rep->_u._uint16Value); |
_toString(out, CIMValueType<Uint16>::ref(_rep)); |
break; | break; |
| |
case CIMTYPE_SINT16: | case CIMTYPE_SINT16: |
_toString(out, _rep->_u._sint16Value); |
_toString(out, CIMValueType<Sint16>::ref(_rep)); |
break; | break; |
| |
case CIMTYPE_UINT32: | case CIMTYPE_UINT32: |
_toString(out, _rep->_u._uint32Value); |
_toString(out, CIMValueType<Uint32>::ref(_rep)); |
break; | break; |
| |
case CIMTYPE_SINT32: | case CIMTYPE_SINT32: |
_toString(out, _rep->_u._sint32Value); |
_toString(out, CIMValueType<Sint32>::ref(_rep)); |
break; | break; |
| |
case CIMTYPE_UINT64: | case CIMTYPE_UINT64: |
_toString(out, _rep->_u._uint64Value); |
_toString(out, CIMValueType<Uint64>::ref(_rep)); |
break; | break; |
| |
case CIMTYPE_SINT64: | case CIMTYPE_SINT64: |
_toString(out, _rep->_u._sint64Value); |
_toString(out, CIMValueType<Sint64>::ref(_rep)); |
break; | break; |
| |
case CIMTYPE_REAL32: | case CIMTYPE_REAL32: |
_toString(out, _rep->_u._real32Value); |
_toString(out, CIMValueType<Real32>::ref(_rep)); |
break; | break; |
| |
case CIMTYPE_REAL64: | case CIMTYPE_REAL64: |
_toString(out, _rep->_u._real64Value); |
_toString(out, CIMValueType<Real64>::ref(_rep)); |
break; | break; |
| |
case CIMTYPE_CHAR16: | case CIMTYPE_CHAR16: |
_toString(out, Char16(_rep->_u._char16Value)); |
_toString(out, CIMValueType<Char16>::ref(_rep)); |
break; | break; |
| |
case CIMTYPE_STRING: | case CIMTYPE_STRING: |
_toString(out, *_rep->_u._stringValue); |
_toString(out, CIMValueType<String>::ref(_rep)); |
break; | break; |
| |
case CIMTYPE_DATETIME: | case CIMTYPE_DATETIME: |
_toString(out, *_rep->_u._dateTimeValue); |
_toString(out, CIMValueType<CIMDateTime>::ref(_rep)); |
break; | break; |
| |
case CIMTYPE_REFERENCE: | case CIMTYPE_REFERENCE: |
_toString(out, *_rep->_u._referenceValue); |
_toString(out, CIMValueType<CIMObjectPath>::ref(_rep)); |
break; | break; |
| |
case CIMTYPE_OBJECT: | case CIMTYPE_OBJECT: |
_toString(out, *_rep->_u._cimobjectValue); |
_toString(out, CIMValueType<CIMObject>::ref(_rep)); |
break; | break; |
| |
default: | default: |
PEGASUS_ASSERT(false); |
PEGASUS_ASSERT(0); |
} | } |
} | } |
| |
out.append('\0'); | out.append('\0'); |
|
|
return out.getData(); | return out.getData(); |
} | } |
| |
|
#ifdef PEGASUS_USE_DEPRECATED_INTERFACES |
|
|
|
CIMValue::CIMValue(char x) |
|
{ |
|
_rep = new CIMValueRep; |
|
CIMValueType<Sint8>::set(_rep, (Sint8)x); |
|
} |
|
|
|
CIMValue::CIMValue(const Array<char>& x) |
|
{ |
|
_rep = new CIMValueRep; |
|
Array<Sint8> tmp((Sint8*)x.getData(), x.size()); |
|
CIMValueType<Sint8>::setArray(_rep, tmp); |
|
} |
|
|
|
void CIMValue::set(char x) |
|
{ |
|
set(static_cast<Sint8>(x)); |
|
} |
|
|
|
void CIMValue::set(const Array<char>& x) |
|
{ |
|
set(*reinterpret_cast<const Array<Sint8>*>(&x)); |
|
} |
|
|
|
void CIMValue::get(char& x) const |
|
{ |
|
get(*reinterpret_cast<Sint8*>(&x)); |
|
} |
|
|
|
void CIMValue::get(Array<char>& x) const |
|
{ |
|
get(*reinterpret_cast<Array<Sint8>*>(&x)); |
|
} |
|
|
|
#endif /* PEGASUS_USE_DEPRECATED_INTERFACES */ |
|
|
|
void CIMValue::_get(const String*& data, Uint32& size) const |
|
{ |
|
const Array<String>& a = CIMValueType<String>::aref(_rep); |
|
data = a.getData(); |
|
size = a.size(); |
|
} |
| |
Boolean operator==(const CIMValue& x, const CIMValue& y) | Boolean operator==(const CIMValue& x, const CIMValue& y) |
{ | { |