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

Return to CIMValue.cpp CVS log

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

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

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

version 1.27, 2002/05/11 21:36:29

Line 32

#include <cassert>

#include <cctype>

#include "CIMValue.h"

#include "Union.h"

#include "Indentor.h"

#include "Exception.h"

#include "XmlWriter.h"

PEGASUS_NAMESPACE_BEGIN

Line 433

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

// CIMValueRep

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

class CIMValueRep

{

public:

CIMValueRep()

{

reset();

}

~CIMValueRep()

{

}

void reset()

{

_type = CIMType::NONE;

_isArray = false;

_isNull = true;

_u._voidPtr = 0;

}

CIMType _type;

Boolean _isArray;

Boolean _isNull;

Union _u;

};

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

// CIMValue

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

CIMValue::CIMValue()

{

_init();

_rep = new CIMValueRep();

}

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

{

_init();

_rep = new CIMValueRep();

setNullValue(type, isArray, arraySize);

}

CIMValue::CIMValue(const CIMValue& x)

CIMValue::CIMValue(Boolean x)

{

_init();

_rep = new CIMValueRep();

assign(x);

set(x);

}

CIMValue::~CIMValue()

CIMValue::CIMValue(Uint8 x)

{

clear();

_rep = new CIMValueRep();

set(x);

}

void CIMValue::assign(const CIMValue& x)

CIMValue::CIMValue(Sint8 x)

{

if (this == &x)

_rep = new CIMValueRep();

return;

set(x);

}

clear();

CIMValue::CIMValue(Uint16 x)

{

_rep = new CIMValueRep();

set(x);

}

_type = x._type;

CIMValue::CIMValue(Sint16 x)

_isArray = x._isArray;

{

_isNull = x._isNull;

_rep = new CIMValueRep();

_u._voidPtr = 0;

set(x);

}

if (_isArray)

CIMValue::CIMValue(Uint32 x)

{

switch (_type)

_rep = new CIMValueRep();

set(x);

}

CIMValue::CIMValue(Sint32 x)

{

case CIMType::BOOLEAN:

_rep = new CIMValueRep();

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

set(x);

break;

}

case CIMType::UINT8:

CIMValue::CIMValue(Uint64 x)

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

{

break;

_rep = new CIMValueRep();

set(x);

}

case CIMType::SINT8:

CIMValue::CIMValue(Sint64 x)

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

{

break;

_rep = new CIMValueRep();

set(x);

}

case CIMType::UINT16:

CIMValue::CIMValue(Real32 x)

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

{

break;

_rep = new CIMValueRep();

set(x);

}

case CIMType::SINT16:

CIMValue::CIMValue(Real64 x)

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

{

break;

_rep = new CIMValueRep();

set(x);

}

case CIMType::UINT32:

CIMValue::CIMValue(const Char16& x)

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

{

break;

_rep = new CIMValueRep();

set(x);

}

case CIMType::SINT32:

CIMValue::CIMValue(const String& x)

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

{

break;

_rep = new CIMValueRep();

set(x);

}

case CIMType::UINT64:

CIMValue::CIMValue(const char* x)

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

{

break;

_rep = new CIMValueRep();

set(x);

}

case CIMType::SINT64:

CIMValue::CIMValue(const CIMDateTime& x)

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

{

break;

_rep = new CIMValueRep();

set(x);

}

case CIMType::REAL32:

CIMValue::CIMValue(const CIMReference& x)

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

{

break;

_rep = new CIMValueRep();

set(x);

}

case CIMType::REAL64:

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

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

{

break;

_rep = new CIMValueRep();

set(x);

}

case CIMType::CHAR16:

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

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

{

break;

_rep = new CIMValueRep();

set(x);

}

case CIMType::STRING:

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

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

{

break;

_rep = new CIMValueRep();

set(x);

}

case CIMType::DATETIME:

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

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

{

break;

_rep = new CIMValueRep();

set(x);

}

case CIMType::REFERENCE:

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

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

{

break;

_rep = new CIMValueRep();

default:

set(x);

throw CIMValueInvalidType();

}

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

{

_rep = new CIMValueRep();

set(x);

}

else

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

{

switch (_type)

_rep = new CIMValueRep();

set(x);

}

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

{

case CIMType::NONE:

_rep = new CIMValueRep();

break;

set(x);

}

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

{

_rep = new CIMValueRep();

set(x);

}

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

{

_rep = new CIMValueRep();

set(x);

}

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

{

_rep = new CIMValueRep();

set(x);

}

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

{

_rep = new CIMValueRep();

set(x);

}

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

{

_rep = new CIMValueRep();

set(x);

}

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

{

_rep = new CIMValueRep();

set(x);

}

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

{

_rep = new CIMValueRep();

set(x);

}

CIMValue::CIMValue(const CIMValue& x)

{

_rep = new CIMValueRep();

assign(x);

}

CIMValue::~CIMValue()

{

clear();

delete _rep;

}

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

{

assign(x);

return *this;

}

void CIMValue::assign(const CIMValue& x)

{

if (this == &x)

return;

clear();

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

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

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

_rep->_u._voidPtr = 0;

if (_rep->_isArray)

{

switch (_rep->_type)

{

case CIMType::BOOLEAN:

_u._booleanValue = x._u._booleanValue;

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

break;

case CIMType::UINT8:

_u._uint8Value = x._u._uint8Value;

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

break;

case CIMType::SINT8:

_u._sint8Value = x._u._sint8Value;

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

break;

case CIMType::UINT16:

_u._uint16Value = x._u._uint16Value;

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

break;

case CIMType::SINT16:

_u._sint16Value = x._u._sint16Value;

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

break;

case CIMType::UINT32:

_u._uint32Value = x._u._uint32Value;

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

break;

case CIMType::SINT32:

_u._sint32Value = x._u._sint32Value;

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

break;

case CIMType::UINT64:

_u._uint64Value = x._u._uint64Value;

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

break;

case CIMType::SINT64:

_u._sint64Value = x._u._sint64Value;

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

break;

case CIMType::REAL32:

_u._real32Value = x._u._real32Value;

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

break;

case CIMType::REAL64:

_u._real64Value = x._u._real64Value;

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

break;

case CIMType::CHAR16:

_u._char16Value = x._u._char16Value;

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

break;

case CIMType::STRING:

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

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

break;

case CIMType::DATETIME:

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

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

break;

case CIMType::REFERENCE:

_u._referenceValue

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

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

break;

// Should never get here. testing complete enum

default:

throw CIMValueInvalidType();

}

else

Uint32 CIMValue::getArraySize() const

{

if (!_isArray)

switch (_rep->_type)

return 0;

switch (_type)

{

case CIMType::NONE:

return 0;

break;

case CIMType::BOOLEAN:

return _u._booleanArray->size;

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

break;

case CIMType::UINT8:

return _u._uint8Array->size;

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

break;

case CIMType::SINT8:

return _u._sint8Array->size;

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

break;

case CIMType::UINT16:

return _u._uint16Array->size;

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

break;

case CIMType::SINT16:

return _u._sint16Array->size;

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

break;

case CIMType::UINT32:

return _u._uint32Array->size;

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

break;

case CIMType::SINT32:

return _u._sint32Array->size;

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

break;

case CIMType::UINT64:

return _u._uint64Array->size;

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

break;

case CIMType::SINT64:

return _u._sint64Array->size;

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

break;

case CIMType::REAL32:

return _u._real32Array->size;

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

break;

case CIMType::REAL64:

return _u._real64Array->size;

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

break;

case CIMType::CHAR16:

return _u._char16Array->size;

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

break;

case CIMType::STRING:

return _u._stringArray->size;

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

break;

case CIMType::DATETIME:

return _u._dateTimeArray->size;

_rep->_u._dateTimeValue =

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

break;

case CIMType::REFERENCE:

return _u._referenceArray->size;

_rep->_u._referenceValue =

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

break;

// Should never get here. switch on complete enum

// Should never get here. testing complete enum

default:

throw CIMValueInvalidType();

}

// Unreachable!

PEGASUS_ASSERT(false);

return 0;

}

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

Line 698

Line 845

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

void CIMValue::clear()

{

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

if (_rep->_isArray)

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

// and that does the isNull=false.

if (_isArray)

{

switch (_type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

_Dec(_u._booleanArray);

_Dec(_rep->_u._booleanArray);

break;

case CIMType::UINT8:

_Dec(_u._uint8Array);

_Dec(_rep->_u._uint8Array);

break;

case CIMType::SINT8:

_Dec(_u._sint8Array);

_Dec(_rep->_u._sint8Array);

break;

case CIMType::UINT16:

_Dec(_u._uint16Array);

_Dec(_rep->_u._uint16Array);

break;

case CIMType::SINT16:

_Dec(_u._sint16Array);

_Dec(_rep->_u._sint16Array);

break;

case CIMType::UINT32:

_Dec(_u._uint32Array);

_Dec(_rep->_u._uint32Array);

break;

case CIMType::SINT32:

_Dec(_u._sint32Array);

_Dec(_rep->_u._sint32Array);

break;

case CIMType::UINT64:

_Dec(_u._uint64Array);

_Dec(_rep->_u._uint64Array);

break;

case CIMType::SINT64:

_Dec(_u._sint64Array);

_Dec(_rep->_u._sint64Array);

break;

case CIMType::REAL32:

_Dec(_u._real32Array);

_Dec(_rep->_u._real32Array);

break;

case CIMType::REAL64:

_Dec(_u._real64Array);

_Dec(_rep->_u._real64Array);

break;

case CIMType::CHAR16:

_Dec(_u._char16Array);

_Dec(_rep->_u._char16Array);

break;

case CIMType::STRING:

_Dec(_u._stringArray);

_Dec(_rep->_u._stringArray);

break;

case CIMType::DATETIME:

_Dec(_u._dateTimeArray);

_Dec(_rep->_u._dateTimeArray);

break;

case CIMType::REFERENCE:

_Dec(_u._referenceArray);

_Dec(_rep->_u._referenceArray);

break;

//default:

Line 772

Line 915

}

else

{

switch (_type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMType::UINT8:

Line 789

Line 932

break;

case CIMType::STRING:

delete _u._stringValue;

delete _rep->_u._stringValue;

break;

case CIMType::DATETIME:

delete _u._dateTimeValue;

delete _rep->_u._dateTimeValue;

break;

case CIMType::REFERENCE:

delete _u._referenceValue;

delete _rep->_u._referenceValue;

break;

//default:

//throw CIMValueInvalidType();

}

_init();

_rep->reset();

}

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

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

{

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

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

Note that it output absolutely nothing. This works for

everything except qualifiers where the value tag is required in

any case per the XML specification

if (_isNull)

{

if (forceTag)

if (_isArray)

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

else

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

return;

}

if (_isArray)

{

switch (_type)

{

case CIMType::BOOLEAN:

{

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

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

// like everybody else?

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

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

Boolean CIMValue::isArray() const

{

out << "<VALUE>";

return _rep->_isArray;

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

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

}

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

break;

}

case CIMType::UINT8:

Boolean CIMValue::isNull() const

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

break;

case CIMType::SINT8:

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

break;

case CIMType::UINT16:

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

break;

case CIMType::SINT16:

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

break;

case CIMType::UINT32:

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

break;

case CIMType::SINT32:

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

break;

case CIMType::UINT64:

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

break;

case CIMType::SINT64:

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

break;

case CIMType::REAL32:

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

break;

case CIMType::REAL64:

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

break;

case CIMType::CHAR16:

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

break;

case CIMType::STRING:

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

break;

case CIMType::DATETIME:

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

break;

case CIMType::REFERENCE:

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

_u._referenceArray->size);

break;

default:

throw CIMValueInvalidType();

}

else if (_type == CIMType::REFERENCE)

{

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

return _rep->_isNull;

_toXml(out, *_u._referenceValue);

}

else

Uint32 CIMValue::getArraySize() const

{

out << "<VALUE>";

if (!_rep->_isArray)

return 0;

switch (_type)

switch (_rep->_type)

{

case CIMType::NONE:

return 0;

break;

case CIMType::BOOLEAN:

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

return _rep->_u._booleanArray->size;

break;

case CIMType::UINT8:

_toXml(out, _u._uint8Value);

return _rep->_u._uint8Array->size;

break;

case CIMType::SINT8:

_toXml(out, _u._sint8Value);

return _rep->_u._sint8Array->size;

break;

case CIMType::UINT16:

_toXml(out, _u._uint16Value);

return _rep->_u._uint16Array->size;

break;

case CIMType::SINT16:

_toXml(out, _u._sint16Value);

return _rep->_u._sint16Array->size;

break;

case CIMType::UINT32:

_toXml(out, _u._uint32Value);

return _rep->_u._uint32Array->size;

break;

case CIMType::SINT32:

_toXml(out, _u._sint32Value);

return _rep->_u._sint32Array->size;

break;

case CIMType::UINT64:

_toXml(out, _u._uint64Value);

return _rep->_u._uint64Array->size;

break;

case CIMType::SINT64:

_toXml(out, _u._sint64Value);

return _rep->_u._sint64Array->size;

break;

case CIMType::REAL32:

_toXml(out, _u._real32Value);

return _rep->_u._real32Array->size;

break;

case CIMType::REAL64:

_toXml(out, _u._real64Value);

return _rep->_u._real64Array->size;

break;

case CIMType::CHAR16:

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

return _rep->_u._char16Array->size;

break;

case CIMType::STRING:

_toXml(out, *_u._stringValue);

return _rep->_u._stringArray->size;

break;

case CIMType::DATETIME:

_toXml(out, *_u._dateTimeValue);

return _rep->_u._dateTimeArray->size;

break;

case CIMType::REFERENCE:

return _rep->_u._referenceArray->size;

break;

// Should never get here. switch on complete enum

default:

throw CIMValueInvalidType();

}

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

// Unreachable!

}

PEGASUS_ASSERT(false);

return 0;

}

String CIMValue::toXml(Boolean forceTag) const

CIMType CIMValue::getType() const

{

Array<Sint8> out;

return CIMType(_rep->_type);

toXml(out, forceTag);

out.append('\0');

return String(out.getData());

}

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

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

{

// if the CIMValue is Null we return nothing.

// The alternative is to return the Null indicator.

if (_isNull)

{

out << "null";

return ;

}

clear();

if (_isArray)

if (isArray)

{

switch (_type)

switch (type)

{

case CIMType::BOOLEAN:

{

set(Array<Boolean>(arraySize));

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

break;

}

case CIMType::UINT8:

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

set(Array<Uint8>(arraySize));

break;

case CIMType::SINT8:

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

set(Array<Sint8>(arraySize));

break;

case CIMType::UINT16:

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

set(Array<Uint16>(arraySize));

break;

case CIMType::SINT16:

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

set(Array<Sint16>(arraySize));

break;

case CIMType::UINT32:

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

set(Array<Uint32>(arraySize));

break;

case CIMType::SINT32:

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

set(Array<Sint32>(arraySize));

break;

case CIMType::UINT64:

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

set(Array<Uint64>(arraySize));

break;

case CIMType::SINT64:

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

set(Array<Sint64>(arraySize));

break;

case CIMType::REAL32:

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

set(Array<Real32>(arraySize));

break;

case CIMType::REAL64:

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

set(Array<Real64>(arraySize));

break;

case CIMType::CHAR16:

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

set(Array<Char16>(arraySize));

break;

case CIMType::STRING:

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

set(Array<String>(arraySize));

break;

case CIMType::DATETIME:

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

set(Array<CIMDateTime>(arraySize));

_u._dateTimeArray->size);

break;

case CIMType::REFERENCE:

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

set(Array<CIMReference>(arraySize));

_u._referenceArray->size);

break;

default:

throw CIMValueInvalidType();

}

else

{

switch (_type)

switch (type)

{

case CIMType::BOOLEAN:

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

set(false);

break;

case CIMType::UINT8:

_toMof(out, _u._uint8Value);

set(Uint8(0));

break;

case CIMType::SINT8:

_toMof(out, _u._sint8Value);

set(Sint8(0));

break;

case CIMType::UINT16:

_toMof(out, _u._uint16Value);

set(Uint16(0));

break;

case CIMType::SINT16:

_toMof(out, _u._sint16Value);

set(Sint16(0));

break;

case CIMType::UINT32:

_toMof(out, _u._uint32Value);

set(Uint32(0));

break;

case CIMType::SINT32:

_toMof(out, _u._sint32Value);

set(Sint32(0));

break;

case CIMType::UINT64:

_toMof(out, _u._uint64Value);

set(Uint64(0));

break;

case CIMType::SINT64:

_toMof(out, _u._sint64Value);

set(Sint64(0));

break;

case CIMType::REAL32:

_toMof(out, _u._real32Value);

set(Real32(0.0));

break;

case CIMType::REAL64:

_toMof(out, _u._real64Value);

set(Real64(0.0));

break;

case CIMType::CHAR16:

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

set(Char16(0));

break;

case CIMType::STRING:

_toMof(out, *_u._stringValue);

set(String());

break;

case CIMType::DATETIME:

_toMof(out, *_u._dateTimeValue);

set(CIMDateTime());

break;

case CIMType::REFERENCE:

_toMof(out, *_u._referenceValue);

set(CIMReference());

break;

default:

throw CIMValueInvalidType();

}

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

// because the set functions sets the _isNull.

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

_rep->_isNull = true;

{

Array<Sint8> tmp;

toXml(tmp, forceTag);

tmp.append('\0');

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

}

void CIMValue::set(Boolean x)

{

clear();

_u._booleanValue = (Uint8)x;

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

_type = CIMType::BOOLEAN;

_rep->_type = CIMType::BOOLEAN;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Uint8 x)

{

clear();

_u._uint8Value = x;

_rep->_u._uint8Value = x;

_type = CIMType::UINT8;

_rep->_type = CIMType::UINT8;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Sint8 x)

{

clear();

_u._sint8Value = x;

_rep->_u._sint8Value = x;

_type = CIMType::SINT8;

_rep->_type = CIMType::SINT8;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Uint16 x)

{

clear();

_u._uint16Value = x;

_rep->_u._uint16Value = x;

_type = CIMType::UINT16;

_rep->_type = CIMType::UINT16;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Sint16 x)

{

clear();

_u._sint16Value = x;

_rep->_u._sint16Value = x;

_type = CIMType::SINT16;

_rep->_type = CIMType::SINT16;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Uint32 x)

{

clear();

_u._uint32Value = x;

_rep->_u._uint32Value = x;

_type = CIMType::UINT32;

_rep->_type = CIMType::UINT32;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Sint32 x)

{

clear();

_u._sint32Value = x;

_rep->_u._sint32Value = x;

_type = CIMType::SINT32;

_rep->_type = CIMType::SINT32;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Uint64 x)

{

clear();

_u._uint64Value = x;

_rep->_u._uint64Value = x;

_type = CIMType::UINT64;

_rep->_type = CIMType::UINT64;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Sint64 x)

{

clear();

_u._sint64Value = x;

_rep->_u._sint64Value = x;

_type = CIMType::SINT64;

_rep->_type = CIMType::SINT64;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Real32 x)

{

clear();

_u._real32Value = x;

_rep->_u._real32Value = x;

_type = CIMType::REAL32;

_rep->_type = CIMType::REAL32;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(Real64 x)

{

clear();

_u._real64Value = x;

_rep->_u._real64Value = x;

_type = CIMType::REAL64;

_rep->_type = CIMType::REAL64;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const Char16& x)

{

clear();

_u._char16Value = x;

_rep->_u._char16Value = x;

_type = CIMType::CHAR16;

_rep->_type = CIMType::CHAR16;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const String& x)

{

clear();

_u._stringValue = new String(x);

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

_type = CIMType::STRING;

_rep->_type = CIMType::STRING;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const char* x)

{

set(String(x));

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const CIMDateTime& x)

{

clear();

_u._dateTimeValue = new CIMDateTime(x);

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

_type = CIMType::DATETIME;

_rep->_type = CIMType::DATETIME;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::set(const CIMReference& x)

{

clear();

_u._referenceValue = new CIMReference(x);

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

_type = CIMType::REFERENCE;

_rep->_type = CIMType::REFERENCE;

_isNull = false;

_rep->_isNull = false;

}

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

{

clear();

_Inc(_u._booleanArray = x._rep);

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

_type = CIMType::BOOLEAN;

_rep->_type = CIMType::BOOLEAN;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

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

{

clear();

_Inc(_u._uint8Array = x._rep);

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

_type = CIMType::UINT8;

_rep->_type = CIMType::UINT8;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

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

{

clear();

_Inc(_u._sint8Array = x._rep);

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

_type = CIMType::SINT8;

_rep->_type = CIMType::SINT8;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

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

{

clear();

_Inc(_u._uint16Array = x._rep);

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

_type = CIMType::UINT16;

_rep->_type = CIMType::UINT16;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

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

{

clear();

_Inc(_u._sint16Array = x._rep);

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

_type = CIMType::SINT16;

_rep->_type = CIMType::SINT16;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

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

{

clear();

_Inc(_u._uint32Array = x._rep);

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

_type = CIMType::UINT32;

_rep->_type = CIMType::UINT32;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

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

{

clear();

_Inc(_u._sint32Array = x._rep);

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

_type = CIMType::SINT32;

_rep->_type = CIMType::SINT32;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

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

{

clear();

_Inc(_u._uint64Array = x._rep);

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

_type = CIMType::UINT64;

_rep->_type = CIMType::UINT64;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

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

{

clear();

_Inc(_u._sint64Array = x._rep);

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

_type = CIMType::SINT64;

_rep->_type = CIMType::SINT64;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

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

{

clear();

_Inc(_u._real32Array = x._rep);

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

_type = CIMType::REAL32;

_rep->_type = CIMType::REAL32;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

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

{

clear();

_Inc(_u._real64Array = x._rep);

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

_type = CIMType::REAL64;

_rep->_type = CIMType::REAL64;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

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

{

clear();

_Inc(_u._char16Array = x._rep);

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

_type = CIMType::CHAR16;

_rep->_type = CIMType::CHAR16;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

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

{

clear();

_Inc(_u._stringArray = x._rep);

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

_type = CIMType::STRING;

_rep->_type = CIMType::STRING;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

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

{

clear();

_Inc(_u._dateTimeArray = x._rep);

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

_type = CIMType::DATETIME;

_rep->_type = CIMType::DATETIME;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

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

{

clear();

_Inc(_u._referenceArray = x._rep);

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

_type = CIMType::REFERENCE;

_rep->_type = CIMType::REFERENCE;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

void CIMValue::get(Boolean& x) const

{

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

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

throw TypeMismatch();

x = _u._booleanValue != 0;

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

}

void CIMValue::get(Uint8& x) const

{

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

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

throw TypeMismatch();

x = _u._uint8Value;

x = _rep->_u._uint8Value;

}

void CIMValue::get(Sint8& x) const

{

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

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

throw TypeMismatch();

x = _u._sint8Value;

x = _rep->_u._sint8Value;

}

void CIMValue::get(Uint16& x) const

{

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

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

throw TypeMismatch();

x = _u._uint16Value;

x = _rep->_u._uint16Value;

}

void CIMValue::get(Sint16& x) const

{

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

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

throw TypeMismatch();

x = _u._sint16Value;

x = _rep->_u._sint16Value;

}

void CIMValue::get(Uint32& x) const

{

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

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

throw TypeMismatch();

x = _u._uint32Value;

x = _rep->_u._uint32Value;

}

void CIMValue::get(Sint32& x) const

{

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

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

throw TypeMismatch();

x = _u._sint32Value;

x = _rep->_u._sint32Value;

}

void CIMValue::get(Uint64& x) const

{

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

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

throw TypeMismatch();

x = _u._uint64Value;

x = _rep->_u._uint64Value;

}

void CIMValue::get(Sint64& x) const

{

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

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

throw TypeMismatch();

x = _u._sint64Value;

x = _rep->_u._sint64Value;

}

void CIMValue::get(Real32& x) const

{

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

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

throw TypeMismatch();

x = _u._real32Value;

x = _rep->_u._real32Value;

}

void CIMValue::get(Real64& x) const

{

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

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

throw TypeMismatch();

x = _u._real64Value;

x = _rep->_u._real64Value;

}

void CIMValue::get(Char16& x) const

{

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

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

throw TypeMismatch();

x = _u._char16Value;

x = _rep->_u._char16Value;

}

void CIMValue::get(String& x) const

{

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

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

throw TypeMismatch();

x = *_u._stringValue;

x = *_rep->_u._stringValue;

}

void CIMValue::get(CIMDateTime& x) const

{

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

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

throw TypeMismatch();

x = *_u._dateTimeValue;

x = *_rep->_u._dateTimeValue;

}

void CIMValue::get(CIMReference& x) const

{

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

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

throw TypeMismatch();

x = *_u._referenceValue;

x = *_rep->_u._referenceValue;

}

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

{

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

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

throw TypeMismatch();

x.set(_u._booleanArray);

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

}

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

{

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

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

throw TypeMismatch();

x.set(_u._uint8Array);

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

}

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

{

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

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

throw TypeMismatch();

x.set(_u._sint8Array);

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

}

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

{

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

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

throw TypeMismatch();

x.set(_u._uint16Array);

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

}

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

{

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

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

throw TypeMismatch();

x.set(_u._sint16Array);

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

}

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

{

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

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

throw TypeMismatch();

x.set(_u._uint32Array);

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

}

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

{

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

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

throw TypeMismatch();

x.set(_u._sint32Array);

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

}

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

{

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

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

throw TypeMismatch();

x.set(_u._uint64Array);

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

}

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

{

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

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

throw TypeMismatch();

x.set(_u._sint64Array);

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

}

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

{

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

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

throw TypeMismatch();

x.set(_u._real32Array);

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

}

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

{

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

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

throw TypeMismatch();

x.set(_u._real64Array);

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

}

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

{

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

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

throw TypeMismatch();

x.set(_u._char16Array);

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

}

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

{

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

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

throw TypeMismatch();

x.set(_u._stringArray);

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

}

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

{

#ifdef CIMValueisNullexception

if (_isNull)

if (_rep->_isNull)

throw CIMValueIsNull();

#endif

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

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

throw TypeMismatch();

x.set(_u._dateTimeArray);

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

}

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

{

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

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

throw TypeMismatch();

x.set(_u._referenceArray);

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

}

void CIMValue::_init()

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

{

_type = CIMType::NONE;

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

_isArray = false;

Note that it output absolutely nothing. This works for

_isNull = true;

everything except qualifiers where the value tag is required in

_u._voidPtr = 0;

any case per the XML specification

}

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

The DMTF has approved a change to the XML Specification

{

that extends the XML Definition to allow the

if (!x.typeCompatible(y))

specification of NULL qualifier values. (CR812)

return false;

if (x._isNull != y._isNull)

The definition of the ELEMENT QUALIFIER is now

return false;

defined as ...

if (x._isArray)

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

if (_rep->_isNull)

{

return;

}

if (_rep->_isArray)

{

switch (x._type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

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

{

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

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

_rep->_u._booleanArray->size);

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

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

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

//{

// out << "<VALUE>";

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

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

//}

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

break;

}

case CIMType::UINT8:

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

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

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

_rep->_u._uint8Array->size);

break;

case CIMType::SINT8:

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

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

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

_rep->_u._sint8Array->size);

break;

case CIMType::UINT16:

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

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

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

_rep->_u._uint16Array->size);

break;

case CIMType::SINT16:

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

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

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

_rep->_u._sint16Array->size);

break;

case CIMType::UINT32:

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

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

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

_rep->_u._uint32Array->size);

break;

case CIMType::SINT32:

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

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

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

_rep->_u._sint32Array->size);

break;

case CIMType::UINT64:

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

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

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

_rep->_u._uint64Array->size);

break;

case CIMType::SINT64:

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

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

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

_rep->_u._sint64Array->size);

break;

case CIMType::REAL32:

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

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

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

_rep->_u._real32Array->size);

break;

case CIMType::REAL64:

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

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

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

_rep->_u._real64Array->size);

break;

case CIMType::CHAR16:

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

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

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

_rep->_u._char16Array->size);

break;

case CIMType::STRING:

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

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

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

_rep->_u._stringArray->size);

break;

case CIMType::DATETIME:

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

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

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

_rep->_u._dateTimeArray->size);

break;

case CIMType::REFERENCE:

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

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

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

_rep->_u._referenceArray->size);

break;

default:

throw CIMValueInvalidType();

}

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

{

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

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

}

else

{

switch (x._type)

out << "<VALUE>";

switch (_rep->_type)

{

case CIMType::BOOLEAN:

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

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

break;

case CIMType::UINT8:

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

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

break;

case CIMType::SINT8:

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

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

break;

case CIMType::UINT16:

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

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

break;

case CIMType::SINT16:

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

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

break;

case CIMType::UINT32:

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

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

break;

case CIMType::SINT32:

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

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

break;

case CIMType::UINT64:

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

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

break;

case CIMType::SINT64:

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

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

break;

case CIMType::REAL32:

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

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

break;

case CIMType::REAL64:

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

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

break;

case CIMType::CHAR16:

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

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

break;

case CIMType::STRING:

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

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

break;

case CIMType::DATETIME:

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

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

break;

case CIMType::REFERENCE:

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

default:

throw CIMValueInvalidType();

}

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

}

// Unreachable!

String CIMValue::toXml() const

return false;

{

Array<Sint8> out;

toXml(out);

out.append('\0');

return String(out.getData());

}

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

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

{

Array<Sint8> tmp;

toXml(tmp);

tmp.append('\0');

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

}

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

{

// if the CIMValue is Null we return nothing.

// The alternative is to return the Null indicator.

if (_rep->_isNull)

{

out << "null";

return ;

}

clear();

if (isArray)

if (_rep->_isArray)

{

switch (type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

set(Array<Boolean>(arraySize));

{

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

_rep->_u._booleanArray->size);

break;

}

case CIMType::UINT8:

set(Array<Uint8>(arraySize));

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

_rep->_u._uint8Array->size);

break;

case CIMType::SINT8:

set(Array<Sint8>(arraySize));

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

_rep->_u._sint8Array->size);

break;

case CIMType::UINT16:

set(Array<Uint16>(arraySize));

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

_rep->_u._uint16Array->size);

break;

case CIMType::SINT16:

set(Array<Sint16>(arraySize));

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

_rep->_u._sint16Array->size);

break;

case CIMType::UINT32:

set(Array<Uint32>(arraySize));

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

_rep->_u._uint32Array->size);

break;

case CIMType::SINT32:

set(Array<Sint32>(arraySize));

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

_rep->_u._sint32Array->size);

break;

case CIMType::UINT64:

set(Array<Uint64>(arraySize));

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

_rep->_u._uint64Array->size);

break;

case CIMType::SINT64:

set(Array<Sint64>(arraySize));

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

_rep->_u._sint64Array->size);

break;

case CIMType::REAL32:

set(Array<Real32>(arraySize));

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

_rep->_u._real32Array->size);

break;

case CIMType::REAL64:

set(Array<Real64>(arraySize));

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

_rep->_u._real64Array->size);

break;

case CIMType::CHAR16:

set(Array<Char16>(arraySize));

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

_rep->_u._char16Array->size);

break;

case CIMType::STRING:

set(Array<String>(arraySize));

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

_rep->_u._stringArray->size);

break;

case CIMType::DATETIME:

set(Array<CIMDateTime>(arraySize));

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

_rep->_u._dateTimeArray->size);

break;

case CIMType::REFERENCE:

set(Array<CIMReference>(arraySize));

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

_rep->_u._referenceArray->size);

break;

default:

throw CIMValueInvalidType();

}

else

{

switch (type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

set(false);

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

break;

case CIMType::UINT8:

set(Uint8(0));

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

break;

case CIMType::SINT8:

set(Sint8(0));

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

break;

case CIMType::UINT16:

set(Uint16(0));

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

break;

case CIMType::SINT16:

set(Sint16(0));

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

break;

case CIMType::UINT32:

set(Uint32(0));

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

break;

case CIMType::SINT32:

set(Sint32(0));

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

break;

case CIMType::UINT64:

set(Uint64(0));

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

break;

case CIMType::SINT64:

set(Sint64(0));

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

break;

case CIMType::REAL32:

set(Real32(0.0));

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

break;

case CIMType::REAL64:

set(Real64(0.0));

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

break;

case CIMType::CHAR16:

set(Char16(0));

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

break;

case CIMType::STRING:

set(String());

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

break;

case CIMType::DATETIME:

set(CIMDateTime());

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

break;

case CIMType::REFERENCE:

set(CIMReference());

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

break;

default:

throw CIMValueInvalidType();

}

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

// because the set functions sets the _isNull.

_isNull = true;

}

String CIMValue::toString() const

Line 1949

Line 2079

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

//Choice return empty string or exception out.

if (_isNull)

if (_rep->_isNull)

return String();

if (_isArray)

if (_rep->_isArray)

{

switch (_type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

{

int size = _u._booleanArray->size;

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

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

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

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

{

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

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

out << " ";

}

break;

}

case CIMType::UINT8:

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

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

_rep->_u._uint8Array->size);

break;

case CIMType::SINT8:

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

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

_rep->_u._sint8Array->size);

break;

case CIMType::UINT16:

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

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

_rep->_u._uint16Array->size);

break;

case CIMType::SINT16:

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

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

_rep->_u._sint16Array->size);

break;

case CIMType::UINT32:

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

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

_rep->_u._uint32Array->size);

break;

case CIMType::SINT32:

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

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

_rep->_u._sint32Array->size);

break;

case CIMType::UINT64:

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

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

_rep->_u._uint64Array->size);

break;

case CIMType::SINT64:

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

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

_rep->_u._sint64Array->size);

break;

case CIMType::REAL32:

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

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

_rep->_u._real32Array->size);

break;

case CIMType::REAL64:

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

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

_rep->_u._real64Array->size);

break;

case CIMType::CHAR16:

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

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

_rep->_u._char16Array->size);

break;

case CIMType::STRING:

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

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

_rep->_u._stringArray->size);

break;

case CIMType::DATETIME:

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

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

_rep->_u._dateTimeArray->size);

break;

case CIMType::REFERENCE:

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

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

_rep->_u._referenceArray->size);

break;

default:

Line 2030

Line 2173

}

else

{

switch (_type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

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

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

break;

case CIMType::UINT8:

_toString(out, _u._uint8Value);

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

break;

case CIMType::SINT8:

_toString(out, _u._sint8Value);

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

break;

case CIMType::UINT16:

_toString(out, _u._uint16Value);

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

break;

case CIMType::SINT16:

_toString(out, _u._sint16Value);

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

break;

case CIMType::UINT32:

_toString(out, _u._uint32Value);

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

break;

case CIMType::SINT32:

_toString(out, _u._sint32Value);

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

break;

case CIMType::UINT64:

_toString(out, _u._uint64Value);

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

break;

case CIMType::SINT64:

_toString(out, _u._sint64Value);

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

break;

case CIMType::REAL32:

_toString(out, _u._real32Value);

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

break;

case CIMType::REAL64:

_toString(out, _u._real64Value);

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

break;

case CIMType::CHAR16:

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

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

break;

case CIMType::STRING:

_toString(out, *_u._stringValue);

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

break;

case CIMType::DATETIME:

_toString(out, *_u._dateTimeValue);

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

break;

case CIMType::REFERENCE:

_toString(out, *_u._referenceValue);

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

break;

default:

Line 2101

Line 2244

return out.getData();

}

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

{

if (!x.typeCompatible(y))

return false;

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

return false;

if (x._rep->_isArray)

{

switch (x._rep->_type)

{

case CIMType::BOOLEAN:

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

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

case CIMType::UINT8:

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

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

case CIMType::SINT8:

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

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

case CIMType::UINT16:

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

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

case CIMType::SINT16:

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

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

case CIMType::UINT32:

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

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

case CIMType::SINT32:

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

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

case CIMType::UINT64:

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

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

case CIMType::SINT64:

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

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

case CIMType::REAL32:

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

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

case CIMType::REAL64:

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

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

case CIMType::CHAR16:

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

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

case CIMType::STRING:

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

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

case CIMType::DATETIME:

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

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

case CIMType::REFERENCE:

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

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

default:

throw CIMValueInvalidType();

}

else

{

switch (x._rep->_type)

{

case CIMType::BOOLEAN:

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

case CIMType::UINT8:

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

case CIMType::SINT8:

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

case CIMType::UINT16:

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

case CIMType::SINT16:

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

case CIMType::UINT32:

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

case CIMType::SINT32:

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

case CIMType::UINT64:

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

case CIMType::SINT64:

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

case CIMType::REAL32:

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

case CIMType::REAL64:

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

case CIMType::CHAR16:

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

case CIMType::STRING:

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

*y._rep->_u._stringValue);

case CIMType::DATETIME:

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

case CIMType::REFERENCE:

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

*y._rep->_u._referenceValue;

default:

throw CIMValueInvalidType();

}

// Unreachable!

return false;

}

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

{

return !operator==(x, y);

}

PEGASUS_NAMESPACE_END

Legend:

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

No CVS admin address has been configured