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.26

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

version 1.26, 2002/05/11 03:07:27

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.

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)

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

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, Boolean forceTag) 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)

if (_rep->_isNull)

{

if (!x.typeCompatible(y))

if (forceTag)

return false;

if (_rep->_isArray)

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

if (x._isNull != y._isNull)

else

return false;

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

return;

if (x._isArray)

}

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(Boolean forceTag) const

return false;

{

Array<Sint8> out;

toXml(out, forceTag);

out.append('\0');

return String(out.getData());

}

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

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

{

Array<Sint8> tmp;

toXml(tmp, forceTag);

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 2074

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

}

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 2239

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.26

No CVS admin address has been configured