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.11.2.7 and 1.37

version 1.11.2.7, 2001/08/14 19:13:00

version 1.37, 2002/08/16 01:28:06

Line 1

//%/////////////////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 22

Line 23

// Author: Mike Brasher (mbrasher@bmc.com)

// Modified By:

// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

// Karl Schopmeyer, (k.schopmeyer@opengroup.org)

// Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

//%/////////////////////////////////////////////////////////////////////////////

#include <cstring>

#include <cstdio>

#include <cassert>

#include <cctype>

#include "CIMValue.h"

#include "Union.h"

#include "Indentor.h"

#include "Exception.h"

#include "XmlWriter.h"

PEGASUS_NAMESPACE_BEGIN

Line 41

Line 44

# include "ArrayImpl.h"

#undef PEGASUS_ARRAY_T

template<class T>

inline void _Inc(ArrayRep<T>* rep)

{

ArrayRep<T>::inc(rep);

}

template<class T>

inline void _Dec(ArrayRep<T>* rep)

{

ArrayRep<T>::dec(rep);

}

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

// Local helper functions:

// _toString routines:

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

//------------------------------------------------------------------------------

inline void _toString(Array<Sint8>& out, Boolean x)

// _SignedIntToStr()

//------------------------------------------------------------------------------

static void _SignedIntToStr(Sint64 x, char* result)

{

if (!result)

return;

if (x == 0)

{

result[0] = '0';

XmlWriter::append(out, x);

result[1] = '\0';

return;

}

char buffer[256];

inline void _toString(Array<Sint8>& out, Uint8 x) { XmlWriter::append(out, Uint32(x)); }

Uint32 len = 0;

inline void _toString(Array<Sint8>& out, Sint8 x) { XmlWriter::append(out, Sint32(x)); }

Boolean negative = false;

inline void _toString(Array<Sint8>& out, Uint16 x) { XmlWriter::append(out, Uint32(x)); }

inline void _toString(Array<Sint8>& out, Sint16 x) { XmlWriter::append(out, Sint32(x)); }

inline void _toString(Array<Sint8>& out, Uint32 x) { XmlWriter::append(out, x); }

inline void _toString(Array<Sint8>& out, Sint32 x) { XmlWriter::append(out, x); }

inline void _toString(Array<Sint8>& out, Uint64 x) { XmlWriter::append(out, x); }

inline void _toString(Array<Sint8>& out, Sint64 x) { XmlWriter::append(out, x); }

inline void _toString(Array<Sint8>& out, Real32 x) { XmlWriter::append(out, Real64(x)); }

inline void _toString(Array<Sint8>& out, Real64 x) { XmlWriter::append(out, x); }

for (Uint32 i = 0; 1; i++)

inline void _toString(Array<Sint8>& out, Char16 x)

{

Sint64 q = x / 10;

// ATTN: How to convert 16-bit characters to printable form?

Sint32 r = x % 10;

out.append(Sint8(x));

}

if (q == 0 && r == 0)

break;

if (r < 0)

inline void _toString(Array<Sint8>& out, const String& x)

{

r = -r;

out << x;

negative = true;

}

buffer[len++] = r + '0';

inline void _toString(Array<Sint8>& out, const CIMDateTime& x)

{

x = q ;

out << x.getString();

}

buffer[len] = '\0';

inline void _toString(Array<Sint8>& out, const CIMObjectPath& x)

{

// If buffer was negative, prepend sign:

out << x.toString();

}

char* q = result;

if (negative)

*q++ = '-';

// Reverse the buffer:

char* p = &buffer[len];

while (len--)

*q++ = *--p;

*q++ = '\0';

template<class T>

void _toString(Array<Sint8>& out, const T* p, Uint32 size)

{

while (size--)

{

_toString(out, *p++);

out << " ";

}

//------------------------------------------------------------------------------

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

// _UnsignedIntToStr()

// CIMValueRep

//------------------------------------------------------------------------------

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

static void _UnsignedIntToStr(Uint64 x, char* result)

class CIMValueRep

{

if (!result)

public:

return;

CIMValueRep()

if (x == 0)

{

result[0] = '0';

reset();

result[1] = '\0';

return;

}

char buffer[256];

~CIMValueRep()

Uint32 len = 0;

Boolean negative = false;

for (Uint32 i = 0; 1; i++)

{

Sint64 q = x / 10;

Sint32 r = x % 10;

if (q == 0 && r == 0)

break;

buffer[len++] = r + '0';

x = q ;

}

buffer[len] = '\0';

void reset()

{

// Reverse the buffer onto output:

_type = CIMTYPE_NONE;

_isArray = false;

char* q = result;

_isNull = true;

_u._voidPtr = 0;

char* p = &buffer[len];

}

while (len--)

CIMType _type;

*q++ = *--p;

Boolean _isArray;

Boolean _isNull;

Union _u;

};

*q++ = '\0';

}

//------------------------------------------------------------------------------

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

// _toXml() and _toMof routines:

// CIMValue

//------------------------------------------------------------------------------

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

inline void _toXml(Array<Sint8>& out, Boolean x)

CIMValue::CIMValue()

{

out << (x ? "TRUE" : "FALSE");

_rep = new CIMValueRep();

}

inline void _toMof(Array<Sint8>& out, Boolean x)

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

{

out << (x ? "TRUE" : "FALSE");

_rep = new CIMValueRep();

setNullValue(type, isArray, arraySize);

}

template<class T>

CIMValue::CIMValue(Boolean x)

inline void _integerToXml(Array<Sint8>& out, const T& x)

{

char buffer[32];

_rep = new CIMValueRep();

sprintf(buffer, "%d", x);

set(x);

out << (char*)buffer;

}

/* ATTNKS template<class T>

inline void _integerToMof(Array<Sint8>& out, const T& x)

CIMValue::CIMValue(Uint8 x)

{

char buffer[32];

_rep = new CIMValueRep();

sprintf(buffer, "%d", x);

set(x);

out << (char*)buffer;

}

inline void _toXml(Array<Sint8>& out, Uint8 x) { _integerToXml(out, x); }

inline void _toMof(Array<Sint8>& out, Uint8 x) { _integerToXml(out, x); }

inline void _toXml(Array<Sint8>& out, Sint8 x) { _integerToXml(out, x); }

inline void _toMof(Array<Sint8>& out, Sint8 x) { _integerToXml(out, x); }

inline void _toXml(Array<Sint8>& out, Uint16 x) { _integerToXml(out, x); }

inline void _toMof(Array<Sint8>& out, Uint16 x) { _integerToXml(out, x); }

inline void _toXml(Array<Sint8>& out, Sint16 x) { _integerToXml(out, x); }

inline void _toMof(Array<Sint8>& out, Sint16 x) { _integerToXml(out, x); }

inline void _toXml(Array<Sint8>& out, Uint32 x) { _integerToXml(out, x); }

inline void _toMof(Array<Sint8>& out, Uint32 x) { _integerToXml(out, x); }

inline void _toXml(Array<Sint8>& out, Sint32 x) { _integerToXml(out, x); }

inline void _toMof(Array<Sint8>& out, Sint32 x) { _integerToXml(out, x); }

inline void _toXml(Array<Sint8>& out, Uint64 x)

CIMValue::CIMValue(Sint8 x)

{

char buffer[128];

_rep = new CIMValueRep();

_UnsignedIntToStr(x, buffer);

set(x);

out << buffer;

}

inline void _toMof(Array<Sint8>& out, Uint64 x)

CIMValue::CIMValue(Uint16 x)

{

char buffer[128];

_rep = new CIMValueRep();

_UnsignedIntToStr(x, buffer);

set(x);

out << buffer;

}

inline void _toXml(Array<Sint8>& out, Sint64 x)

CIMValue::CIMValue(Sint16 x)

{

char buffer[128];

_rep = new CIMValueRep();

_SignedIntToStr(x, buffer);

set(x);

out << buffer;

}

inline void _toMof(Array<Sint8>& out, Sint64 x)

CIMValue::CIMValue(Uint32 x)

{

char buffer[128];

_rep = new CIMValueRep();

_SignedIntToStr(x, buffer);

set(x);

out << buffer;

}

void _toXml(Array<Sint8>& out, Real32 x)

CIMValue::CIMValue(Sint32 x)

{

// ATTN: Does this format match the CIM/XML format?

_rep = new CIMValueRep();

char buffer[128];

set(x);

sprintf(buffer, "%f", x);

out << buffer;

}

void _toMof(Array<Sint8>& out, Real32 x)

CIMValue::CIMValue(Uint64 x)

{

// ATTN: Does this format match the CIM/XML format?

_rep = new CIMValueRep();

char buffer[128];

set(x);

sprintf(buffer, "%f", x);

out << buffer;

}

void _toXml(Array<Sint8>& out, Real64 x)

CIMValue::CIMValue(Sint64 x)

{

char buffer[128];

_rep = new CIMValueRep();

sprintf(buffer, "%f", x);

set(x);

out << buffer;

}

void _toMof(Array<Sint8>& out, Real64 x)

CIMValue::CIMValue(Real32 x)

{

char buffer[128];

_rep = new CIMValueRep();

sprintf(buffer, "%f", x);

set(x);

out << buffer;

}

inline void _toXml(Array<Sint8>& out, Char16 x)

CIMValue::CIMValue(Real64 x)

{

XmlWriter::appendSpecial(out, x);

_rep = new CIMValueRep();

set(x);

}

inline void _toMof(Array<Sint8>& out, Char16 x)

CIMValue::CIMValue(const Char16& x)

{

XmlWriter::appendSpecial(out, x);

_rep = new CIMValueRep();

set(x);

}

inline void _toXml(Array<Sint8>& out, const String& x)

CIMValue::CIMValue(const String& x)

{

XmlWriter::appendSpecial(out, x);

_rep = new CIMValueRep();

set(x);

}

/** _toMof Internal function to convert the string back

CIMValue::CIMValue(const CIMDateTime& x)

to MOF format and output it.

The conversions are:

\b // \x0008: backspace BS

\t // \x0009: horizontal tab HT

\n // \x000A: linefeed LF

\f // \x000C: form feed FF

\r // \x000D: carriage return CR

\" // \x0022: double quote "

\� // \x0027: single quote '

\\ // \x005C: backslash \

\x<hex> // where <hex> is one to four hex digits

\X<hex> // where <hex> is one to four hex digits

/* ATTN:KS - We need to account for characters greater than x'7f

inline void _toMof(Array<Sint8>& out, const String& x)

{

out << "\"";

const Char16* tmp = x.getData();

char c;

while (c = *tmp++)

{

switch (c)

{

case '\\':

_rep = new CIMValueRep();

out.append("\\\\",2);

set(x);

break;

case '\b':

out.append("\\b",2);

break;

case '\t':

out.append("\\t",2);

break;

case '\n':

out.append("\\n",2);

break;

case '\f':

out.append("\\f",2);

break;

case '\r':

out.append("\\r",2);

break;

/* case '\'':

out.append("\\'", 2);

break;*/

case '"':

out.append("\\\"", 2);

break;

default:

out.append(Sint8(c));

}

CIMValue::CIMValue(const CIMObjectPath& x)

out << "\"";

{

_rep = new CIMValueRep();

set(x);

}

inline void _toXml(Array<Sint8>& out, const CIMDateTime& x)

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

{

out << x.getString();

_rep = new CIMValueRep();

set(x);

}

inline void _toMof(Array<Sint8>& out, const CIMDateTime& x)

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

{

out << x.getString();

_rep = new CIMValueRep();

set(x);

}

template<class T>

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

void _toXml(Array<Sint8>& out, const T* p, Uint32 size)

{

while (size--)

_rep = new CIMValueRep();

{

set(x);

out << "<VALUE>";

_toXml(out, *p++);

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

}

/** _toMof Array -

arrayInitializer = "{" constantValue*( "," constantValue)"}"

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

template<class T>

void _toMof(Array<Sint8>& out, const T* p, Uint32 size)

{

Boolean isFirstEntry = true;

_rep = new CIMValueRep();

// if there are any entries in the array output them

set(x);

if (size)

}

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

{

out << "{";

_rep = new CIMValueRep();

while (size--)

set(x);

}

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

{

// Put comma on all but first entry.

_rep = new CIMValueRep();

if (!isFirstEntry)

set(x);

}

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

{

out << ", ";

_rep = new CIMValueRep();

set(x);

}

isFirstEntry = false;

_toMof(out, *p++);

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

{

_rep = new CIMValueRep();

set(x);

}

out << "}";

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

{

_rep = new CIMValueRep();

set(x);

}

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

{

_rep = new CIMValueRep();

set(x);

}

template<class T>

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

void _toStr(Array<Sint8>& out, const T* p, Uint32 size)

{

while (size--)

_rep = new CIMValueRep();

set(x);

}

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

{

_toXml(out, *p++);

_rep = new CIMValueRep();

out << " ";

set(x);

}

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

{

_rep = new CIMValueRep();

set(x);

}

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

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

{

// CIMValue

_rep = new CIMValueRep();

set(x);

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

}

CIMValue::CIMValue()

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

{

_init();

_rep = new CIMValueRep();

set(x);

}

CIMValue::CIMValue(const CIMValue& x)

{

_init();

_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)

Line 436

Line 353

clear();

_type = x._type;

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

_isArray = x._isArray;

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

_isNull = x._isNull;

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

_u._voidPtr = 0;

_rep->_u._voidPtr = 0;

if (_isArray)

if (_rep->_isArray)

{

switch (_type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

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

_rep->_u._booleanArray =

new Array<Boolean>(*(x._rep->_u._booleanArray));

break;

case CIMTYPE_UINT8:

_rep->_u._uint8Array =

new Array<Uint8>(*(x._rep->_u._uint8Array));

break;

case CIMType::UINT8:

case CIMTYPE_SINT8:

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

_rep->_u._sint8Array =

new Array<Sint8>(*(x._rep->_u._sint8Array));

break;

case CIMType::SINT8:

case CIMTYPE_UINT16:

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

_rep->_u._uint16Array =

new Array<Uint16>(*(x._rep->_u._uint16Array));

break;

case CIMType::UINT16:

case CIMTYPE_SINT16:

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

_rep->_u._sint16Array =

new Array<Sint16>(*(x._rep->_u._sint16Array));

break;

case CIMType::SINT16:

case CIMTYPE_UINT32:

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

_rep->_u._uint32Array =

new Array<Uint32>(*(x._rep->_u._uint32Array));

break;

case CIMType::UINT32:

case CIMTYPE_SINT32:

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

_rep->_u._sint32Array =

new Array<Sint32>(*(x._rep->_u._sint32Array));

break;

case CIMType::SINT32:

case CIMTYPE_UINT64:

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

_rep->_u._uint64Array =

new Array<Uint64>(*(x._rep->_u._uint64Array));

break;

case CIMType::UINT64:

case CIMTYPE_SINT64:

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

_rep->_u._sint64Array =

new Array<Sint64>(*(x._rep->_u._sint64Array));

break;

case CIMType::SINT64:

case CIMTYPE_REAL32:

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

_rep->_u._real32Array =

new Array<Real32>(*(x._rep->_u._real32Array));

break;

case CIMType::REAL32:

case CIMTYPE_REAL64:

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

_rep->_u._real64Array =

new Array<Real64>(*(x._rep->_u._real64Array));

break;

case CIMType::REAL64:

case CIMTYPE_CHAR16:

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

_rep->_u._char16Array =

new Array<Char16>(*(x._rep->_u._char16Array));

break;

case CIMType::CHAR16:

case CIMTYPE_STRING:

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

_rep->_u._stringArray =

new Array<String>(*(x._rep->_u._stringArray));

break;

case CIMType::STRING:

case CIMTYPE_DATETIME:

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

_rep->_u._dateTimeArray =

new Array<CIMDateTime>(*(x._rep->_u._dateTimeArray));

break;

case CIMType::DATETIME:

case CIMTYPE_REFERENCE:

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

_rep->_u._referenceArray =

new Array<CIMObjectPath>(*(x._rep->_u._referenceArray));

break;

default:

throw CIMValueInvalidType();

}

else

{

switch (_type)

switch (_rep->_type)

{

case CIMType::NONE:

case CIMTYPE_NONE:

break;

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

_u._booleanValue = x._u._booleanValue;

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

break;

case CIMType::UINT8:

case CIMTYPE_UINT8:

_u._uint8Value = x._u._uint8Value;

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

break;

case CIMType::SINT8:

case CIMTYPE_SINT8:

_u._sint8Value = x._u._sint8Value;

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

break;

case CIMType::UINT16:

case CIMTYPE_UINT16:

_u._uint16Value = x._u._uint16Value;

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

break;

case CIMType::SINT16:

case CIMTYPE_SINT16:

_u._sint16Value = x._u._sint16Value;

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

break;

case CIMType::UINT32:

case CIMTYPE_UINT32:

_u._uint32Value = x._u._uint32Value;

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

break;

case CIMType::SINT32:

case CIMTYPE_SINT32:

_u._sint32Value = x._u._sint32Value;

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

break;

case CIMType::UINT64:

case CIMTYPE_UINT64:

_u._uint64Value = x._u._uint64Value;

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

break;

case CIMType::SINT64:

case CIMTYPE_SINT64:

_u._sint64Value = x._u._sint64Value;

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

break;

case CIMType::REAL32:

case CIMTYPE_REAL32:

_u._real32Value = x._u._real32Value;

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

break;

case CIMType::REAL64:

case CIMTYPE_REAL64:

_u._real64Value = x._u._real64Value;

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

break;

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

_u._char16Value = x._u._char16Value;

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

break;

case CIMType::STRING:

case CIMTYPE_STRING:

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

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

break;

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

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

_rep->_u._dateTimeValue =

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

break;

case CIMType::REFERENCE:

case CIMTYPE_REFERENCE:

_u._referenceValue

_rep->_u._referenceValue =

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

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

break;

// Should never get here. testing complete enum

default:

throw CIMValueInvalidType();

}

Uint32 CIMValue::getArraySize() const

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

// gets an exception very early. Disabled the exceptions to keep compiler running for

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

void CIMValue::clear()

{

if (!_isArray)

if (_rep->_isArray)

return 0;

switch (_type)

{

case CIMType::NONE:

switch (_rep->_type)

return 0;

{

break;

case CIMTYPE_BOOLEAN:

delete _rep->_u._booleanArray;

case CIMType::BOOLEAN:

return _u._booleanArray->size;

break;

case CIMType::UINT8:

return _u._uint8Array->size;

break;

case CIMType::SINT8:

return _u._sint8Array->size;

break;

case CIMType::UINT16:

return _u._uint16Array->size;

break;

case CIMType::SINT16:

return _u._sint16Array->size;

break;

case CIMType::UINT32:

return _u._uint32Array->size;

break;

case CIMType::SINT32:

return _u._sint32Array->size;

break;

case CIMType::UINT64:

return _u._uint64Array->size;

break;

case CIMType::SINT64:

return _u._sint64Array->size;

break;

case CIMType::REAL32:

return _u._real32Array->size;

break;

case CIMType::REAL64:

return _u._real64Array->size;

break;

case CIMType::CHAR16:

return _u._char16Array->size;

break;

case CIMType::STRING:

return _u._stringArray->size;

break;

case CIMType::DATETIME:

case CIMTYPE_UINT8:

return _u._dateTimeArray->size;

delete _rep->_u._uint8Array;

break;

case CIMType::REFERENCE:

case CIMTYPE_SINT8:

return 0;

delete _rep->_u._sint8Array;

}

// Unreachable!

return 0;

}

void CIMValue::clear()

{

if (_isArray)

{

switch (_type)

{

case CIMType::BOOLEAN:

_Dec(_u._booleanArray);

break;

case CIMType::UINT8:

case CIMTYPE_UINT16:

_Dec(_u._uint8Array);

delete _rep->_u._uint16Array;

break;

case CIMType::SINT8:

case CIMTYPE_SINT16:

_Dec(_u._sint8Array);

delete _rep->_u._sint16Array;

break;

case CIMType::UINT16:

case CIMTYPE_UINT32:

_Dec(_u._uint16Array);

delete _rep->_u._uint32Array;

break;

case CIMType::SINT16:

case CIMTYPE_SINT32:

_Dec(_u._sint16Array);

delete _rep->_u._sint32Array;

break;

case CIMType::UINT32:

case CIMTYPE_UINT64:

_Dec(_u._uint32Array);

delete _rep->_u._uint64Array;

break;

case CIMType::SINT32:

case CIMTYPE_SINT64:

_Dec(_u._sint32Array);

delete _rep->_u._sint64Array;

break;

case CIMType::UINT64:

case CIMTYPE_REAL32:

_Dec(_u._uint64Array);

delete _rep->_u._real32Array;

break;

case CIMType::SINT64:

case CIMTYPE_REAL64:

_Dec(_u._sint64Array);

delete _rep->_u._real64Array;

break;

case CIMType::REAL32:

case CIMTYPE_CHAR16:

_Dec(_u._real32Array);

delete _rep->_u._char16Array;

break;

case CIMType::REAL64:

case CIMTYPE_STRING:

_Dec(_u._real64Array);

delete _rep->_u._stringArray;

break;

case CIMType::CHAR16:

case CIMTYPE_DATETIME:

_Dec(_u._char16Array);

delete _rep->_u._dateTimeArray;

break;

case CIMType::STRING:

case CIMTYPE_REFERENCE:

_Dec(_u._stringArray);

delete _rep->_u._referenceArray;

break;

case CIMType::DATETIME:

//default:

_Dec(_u._dateTimeArray);

//throw CIMValueInvalidType();

break;

}

else

{

switch (_type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

case CIMType::UINT8:

case CIMTYPE_UINT8:

case CIMType::SINT8:

case CIMTYPE_SINT8:

case CIMType::UINT16:

case CIMTYPE_UINT16:

case CIMType::SINT16:

case CIMTYPE_SINT16:

case CIMType::UINT32:

case CIMTYPE_UINT32:

case CIMType::SINT32:

case CIMTYPE_SINT32:

case CIMType::UINT64:

case CIMTYPE_UINT64:

case CIMType::SINT64:

case CIMTYPE_SINT64:

case CIMType::REAL32:

case CIMTYPE_REAL32:

case CIMType::REAL64:

case CIMTYPE_REAL64:

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

break;

case CIMType::STRING:

case CIMTYPE_STRING:

delete _u._stringValue;

delete _rep->_u._stringValue;

break;

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

delete _u._dateTimeValue;

delete _rep->_u._dateTimeValue;

break;

case CIMType::REFERENCE:

case CIMTYPE_REFERENCE:

delete _u._referenceValue;

delete _rep->_u._referenceValue;

break;

//default:

//throw CIMValueInvalidType();

}

_init();

_rep->reset();

}

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

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

{

if (_isArray)

{

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

return (_rep->_type == x._rep->_type &&

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

// getArraySize() == x.getArraySize());

}

switch (_type)

Boolean CIMValue::isArray() const

{

case CIMType::BOOLEAN:

return _rep->_isArray;

{

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

{

out << "<VALUE>";

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

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

}

break;

}

case CIMType::UINT8:

Boolean CIMValue::isNull() const

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

{

break;

return _rep->_isNull;

}

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:

Uint32 CIMValue::getArraySize() const

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

{

break;

if (!_rep->_isArray)

return 0;

case CIMType::UINT32:

switch (_rep->_type)

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

{

case CIMTYPE_NONE:

return 0;

break;

case CIMType::SINT32:

case CIMTYPE_BOOLEAN:

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

return _rep->_u._booleanArray->size();

break;

case CIMType::UINT64:

case CIMTYPE_UINT8:

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

return _rep->_u._uint8Array->size();

break;

case CIMType::SINT64:

case CIMTYPE_SINT8:

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

return _rep->_u._sint8Array->size();

break;

case CIMType::REAL32:

case CIMTYPE_UINT16:

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

return _rep->_u._uint16Array->size();

break;

case CIMType::REAL64:

case CIMTYPE_SINT16:

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

return _rep->_u._sint16Array->size();

break;

case CIMType::CHAR16:

case CIMTYPE_UINT32:

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

return _rep->_u._uint32Array->size();

break;

case CIMType::STRING:

case CIMTYPE_SINT32:

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

return _rep->_u._sint32Array->size();

break;

case CIMType::DATETIME:

case CIMTYPE_UINT64:

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

return _rep->_u._uint64Array->size();

break;

}

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

case CIMTYPE_SINT64:

}

return _rep->_u._sint64Array->size();

else if (_type == CIMType::REFERENCE)

{

_u._referenceValue->toXml(out);

}

else

{

out << "<VALUE>";

switch (_type)

{

case CIMType::BOOLEAN:

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

break;

case CIMType::UINT8:

case CIMTYPE_REAL32:

_toXml(out, _u._uint8Value);

return _rep->_u._real32Array->size();

break;

case CIMType::SINT8:

case CIMTYPE_REAL64:

_toXml(out, _u._sint8Value);

return _rep->_u._real64Array->size();

break;

case CIMType::UINT16:

case CIMTYPE_CHAR16:

_toXml(out, _u._uint16Value);

return _rep->_u._char16Array->size();

break;

case CIMType::SINT16:

case CIMTYPE_STRING:

_toXml(out, _u._sint16Value);

return _rep->_u._stringArray->size();

break;

case CIMType::UINT32:

case CIMTYPE_DATETIME:

_toXml(out, _u._uint32Value);

return _rep->_u._dateTimeArray->size();

break;

case CIMType::SINT32:

case CIMTYPE_REFERENCE:

_toXml(out, _u._sint32Value);

return _rep->_u._referenceArray->size();

break;

// Should never get here. switch on complete enum

default:

throw CIMValueInvalidType();

}

case CIMType::UINT64:

// Unreachable!

_toXml(out, _u._uint64Value);

PEGASUS_ASSERT(false);

break;

return 0;

}

case CIMType::SINT64:

CIMType CIMValue::getType() const

_toXml(out, _u._sint64Value);

{

break;

return CIMType(_rep->_type);

}

case CIMType::REAL32:

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

_toXml(out, _u._real32Value);

{

break;

case CIMType::REAL64:

clear();

_toXml(out, _u._real64Value);

break;

case CIMType::CHAR16:

if (isArray)

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

{

switch (type)

{

case CIMTYPE_BOOLEAN:

set(Array<Boolean>(arraySize));

break;

case CIMType::STRING:

case CIMTYPE_UINT8:

_toXml(out, *_u._stringValue);

set(Array<Uint8>(arraySize));

break;

case CIMType::DATETIME:

case CIMTYPE_SINT8:

_toXml(out, *_u._dateTimeValue);

set(Array<Sint8>(arraySize));

break;

}

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

case CIMTYPE_UINT16:

}

set(Array<Uint16>(arraySize));

}

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

{

if (_isArray)

{

switch (_type)

{

case CIMType::BOOLEAN:

{

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

{

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

}

break;

}

case CIMType::UINT8:

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

break;

case CIMType::SINT8:

case CIMTYPE_SINT16:

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

set(Array<Sint16>(arraySize));

break;

case CIMType::UINT16:

case CIMTYPE_UINT32:

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

set(Array<Uint32>(arraySize));

break;

case CIMType::SINT16:

case CIMTYPE_SINT32:

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

set(Array<Sint32>(arraySize));

break;

case CIMType::UINT32:

case CIMTYPE_UINT64:

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

set(Array<Uint64>(arraySize));

break;

case CIMType::SINT32:

case CIMTYPE_SINT64:

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

set(Array<Sint64>(arraySize));

break;

case CIMType::UINT64:

case CIMTYPE_REAL32:

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

set(Array<Real32>(arraySize));

break;

case CIMType::SINT64:

case CIMTYPE_REAL64:

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

set(Array<Real64>(arraySize));

break;

case CIMType::REAL32:

case CIMTYPE_CHAR16:

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

set(Array<Char16>(arraySize));

break;

case CIMType::REAL64:

case CIMTYPE_STRING:

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

set(Array<String>(arraySize));

break;

case CIMType::CHAR16:

case CIMTYPE_DATETIME:

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

set(Array<CIMDateTime>(arraySize));

break;

case CIMType::STRING:

case CIMTYPE_REFERENCE:

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

set(Array<CIMObjectPath>(arraySize));

break;

default:

case CIMType::DATETIME:

throw CIMValueInvalidType();

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

_u._dateTimeArray->size); break;

}

else if (_type == CIMType::REFERENCE)

{

_u._referenceValue->toMof(out);

}

else

{

switch (_type)

switch (type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

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

set(false);

break;

case CIMType::UINT8:

case CIMTYPE_UINT8:

_toMof(out, _u._uint8Value);

set(Uint8(0));

break;

case CIMType::SINT8:

case CIMTYPE_SINT8:

_toMof(out, _u._sint8Value);

set(Sint8(0));

break;

case CIMType::UINT16:

case CIMTYPE_UINT16:

_toMof(out, _u._uint16Value);

set(Uint16(0));

break;

case CIMType::SINT16:

case CIMTYPE_SINT16:

_toMof(out, _u._sint16Value);

set(Sint16(0));

break;

case CIMType::UINT32:

case CIMTYPE_UINT32:

_toMof(out, _u._uint32Value);

set(Uint32(0));

break;

case CIMType::SINT32:

case CIMTYPE_SINT32:

_toMof(out, _u._sint32Value);

set(Sint32(0));

break;

case CIMType::UINT64:

case CIMTYPE_UINT64:

_toMof(out, _u._uint64Value);

set(Uint64(0));

break;

case CIMType::SINT64:

case CIMTYPE_SINT64:

_toMof(out, _u._sint64Value);

set(Sint64(0));

break;

case CIMType::REAL32:

case CIMTYPE_REAL32:

_toMof(out, _u._real32Value);

set(Real32(0.0));

break;

case CIMType::REAL64:

case CIMTYPE_REAL64:

_toMof(out, _u._real64Value);

set(Real64(0.0));

break;

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

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

set(Char16(0));

break;

case CIMType::STRING:

case CIMTYPE_STRING:

_toMof(out, *_u._stringValue);

set(String());

break;

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

_toMof(out, *_u._dateTimeValue);

set(CIMDateTime());

break;

}

case CIMTYPE_REFERENCE:

set(CIMObjectPath());

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(PEGASUS_STD(ostream) &os) const

_rep->_isNull = true;

{

Array<Sint8> tmp;

toXml(tmp);

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;

_rep->_isNull = false;

}

void CIMValue::set(Uint8 x)

{

clear();

_u._uint8Value = x;

_rep->_u._uint8Value = x;

_type = CIMType::UINT8;

_rep->_type = CIMTYPE_UINT8;

_rep->_isNull = false;

}

void CIMValue::set(Sint8 x)

{

clear();

_u._sint8Value = x;

_rep->_u._sint8Value = x;

_type = CIMType::SINT8;

_rep->_type = CIMTYPE_SINT8;

_rep->_isNull = false;

}

void CIMValue::set(Uint16 x)

{

clear();

_u._uint16Value = x;

_rep->_u._uint16Value = x;

_type = CIMType::UINT16;

_rep->_type = CIMTYPE_UINT16;

_rep->_isNull = false;

}

void CIMValue::set(Sint16 x)

{

clear();

_u._sint16Value = x;

_rep->_u._sint16Value = x;

_type = CIMType::SINT16;

_rep->_type = CIMTYPE_SINT16;

_rep->_isNull = false;

}

void CIMValue::set(Uint32 x)

{

clear();

_u._uint32Value = x;

_rep->_u._uint32Value = x;

_type = CIMType::UINT32;

_rep->_type = CIMTYPE_UINT32;

_rep->_isNull = false;

}

void CIMValue::set(Sint32 x)

{

clear();

_u._sint32Value = x;

_rep->_u._sint32Value = x;

_type = CIMType::SINT32;

_rep->_type = CIMTYPE_SINT32;

_rep->_isNull = false;

}

void CIMValue::set(Uint64 x)

{

clear();

_u._uint64Value = x;

_rep->_u._uint64Value = x;

_type = CIMType::UINT64;

_rep->_type = CIMTYPE_UINT64;

_rep->_isNull = false;

}

void CIMValue::set(Sint64 x)

{

clear();

_u._sint64Value = x;

_rep->_u._sint64Value = x;

_type = CIMType::SINT64;

_rep->_type = CIMTYPE_SINT64;

_rep->_isNull = false;

}

void CIMValue::set(Real32 x)

{

clear();

_u._real32Value = x;

_rep->_u._real32Value = x;

_type = CIMType::REAL32;

_rep->_type = CIMTYPE_REAL32;

_rep->_isNull = false;

}

void CIMValue::set(Real64 x)

{

clear();

_u._real64Value = x;

_rep->_u._real64Value = x;

_type = CIMType::REAL64;

_rep->_type = CIMTYPE_REAL64;

_rep->_isNull = false;

}

void CIMValue::set(const Char16& x)

{

clear();

_u._char16Value = x;

_rep->_u._char16Value = x;

_type = CIMType::CHAR16;

_rep->_type = CIMTYPE_CHAR16;

_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;

}

_rep->_isNull = false;

void CIMValue::set(const char* x)

{

set(String(x));

}

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;

_rep->_isNull = false;

}

void CIMValue::set(const CIMReference& x)

void CIMValue::set(const CIMObjectPath& x)

{

clear();

_u._referenceValue = new CIMReference(x);

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

_type = CIMType::REFERENCE;

_rep->_type = CIMTYPE_REFERENCE;

_rep->_isNull = false;

}

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

{

clear();

_Inc(_u._booleanArray = x._rep);

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

_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);

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

_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);

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

_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);

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

_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);

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

_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);

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

_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);

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

_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);

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

_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);

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

_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);

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

_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);

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

_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);

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

_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);

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

_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);

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

_type = CIMType::DATETIME;

_rep->_type = CIMTYPE_DATETIME;

_isArray = true;

_rep->_isArray = true;

_isNull = false;

_rep->_isNull = false;

}

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

{

clear();

_rep->_u._referenceArray = new Array<CIMObjectPath>(x);

_rep->_type = CIMTYPE_REFERENCE;

_rep->_isArray = true;

_rep->_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

void CIMValue::get(CIMObjectPath& 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 = *_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 = *_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 = *_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 = *_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 = *_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 = *_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 = *_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 = *_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 = *_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 = *_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 = *_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 = *_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 = *_rep->_u._stringArray;

}

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

{

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

// ATTN-RK-20020815: Use UninitializedObject exception here if CIMValue is null?

if (_rep->_type != CIMTYPE_DATETIME || !_rep->_isArray)

throw TypeMismatch();

x.set(_u._dateTimeArray);

x = *_rep->_u._dateTimeArray;

}

void CIMValue::_init()

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

{

_type = CIMType::NONE;

if (_rep->_type != CIMTYPE_REFERENCE || !_rep->_isArray)

_isArray = false;

throw TypeMismatch();

_isNull = true;

_u._voidPtr = 0;

x = *_rep->_u._referenceArray;

}

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

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

{

if (!x.typeCompatible(y))

if (!typeCompatible(x))

return false;

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

return false;

if (x._isArray)

if (_rep->_isArray)

{

switch (x._type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

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

return (*_rep->_u._booleanArray) ==

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

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

case CIMTYPE_UINT8:

return (*_rep->_u._uint8Array) ==

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

case CIMType::UINT8:

case CIMTYPE_SINT8:

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

return (*_rep->_u._sint8Array) ==

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

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

case CIMType::SINT8:

case CIMTYPE_UINT16:

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

return (*_rep->_u._uint16Array) ==

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

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

case CIMType::UINT16:

case CIMTYPE_SINT16:

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

return (*_rep->_u._sint16Array) ==

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

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

case CIMType::SINT16:

case CIMTYPE_UINT32:

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

return (*_rep->_u._uint32Array) ==

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

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

case CIMType::UINT32:

case CIMTYPE_SINT32:

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

return (*_rep->_u._sint32Array) ==

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

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

case CIMType::SINT32:

case CIMTYPE_UINT64:

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

return (*_rep->_u._uint64Array) ==

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

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

case CIMType::UINT64:

case CIMTYPE_SINT64:

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

return (*_rep->_u._sint64Array) ==

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

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

case CIMType::SINT64:

case CIMTYPE_REAL32:

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

return (*_rep->_u._real32Array) ==

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

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

case CIMType::REAL32:

case CIMTYPE_REAL64:

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

return (*_rep->_u._real64Array) ==

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

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

case CIMType::REAL64:

case CIMTYPE_CHAR16:

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

return (*_rep->_u._char16Array) ==

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

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

case CIMType::CHAR16:

case CIMTYPE_STRING:

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

return (*_rep->_u._stringArray) ==

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

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

case CIMType::STRING:

case CIMTYPE_DATETIME:

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

return (*_rep->_u._dateTimeArray) ==

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

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

case CIMType::DATETIME:

case CIMTYPE_REFERENCE:

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

return (*_rep->_u._referenceArray) ==

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

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

default:

throw CIMValueInvalidType();

}

else

{

switch (x._type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

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

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

case CIMTYPE_UINT8:

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

case CIMType::UINT8:

case CIMTYPE_SINT8:

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

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

case CIMType::SINT8:

case CIMTYPE_UINT16:

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

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

case CIMType::UINT16:

case CIMTYPE_SINT16:

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

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

case CIMType::SINT16:

case CIMTYPE_UINT32:

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

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

case CIMType::UINT32:

case CIMTYPE_SINT32:

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

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

case CIMType::SINT32:

case CIMTYPE_UINT64:

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

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

case CIMType::UINT64:

case CIMTYPE_SINT64:

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

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

case CIMType::SINT64:

case CIMTYPE_REAL32:

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

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

case CIMType::REAL32:

case CIMTYPE_REAL64:

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

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

case CIMType::REAL64:

case CIMTYPE_CHAR16:

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

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

case CIMType::CHAR16:

case CIMTYPE_STRING:

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

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

*x._rep->_u._stringValue);

case CIMType::STRING:

case CIMTYPE_DATETIME:

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

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

case CIMType::DATETIME:

case CIMTYPE_REFERENCE:

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

return *_rep->_u._referenceValue ==

*x._rep->_u._referenceValue;

case CIMType::REFERENCE:

default:

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

throw CIMValueInvalidType();

}

Line 1630

Line 1506

return false;

}

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

{

_isNull = true;

clear();

if (isArray)

{

switch (type)

{

case CIMType::BOOLEAN:

set(Array<Boolean>(arraySize));

break;

case CIMType::UINT8:

set(Array<Uint8>(arraySize));

break;

case CIMType::SINT8:

set(Array<Sint8>(arraySize));

break;

case CIMType::UINT16:

set(Array<Uint16>(arraySize));

break;

case CIMType::SINT16:

set(Array<Sint16>(arraySize));

break;

case CIMType::UINT32:

set(Array<Uint32>(arraySize));

break;

case CIMType::SINT32:

set(Array<Sint32>(arraySize));

break;

case CIMType::UINT64:

set(Array<Uint64>(arraySize));

break;

case CIMType::SINT64:

set(Array<Sint64>(arraySize));

break;

case CIMType::REAL32:

set(Array<Real32>(arraySize));

break;

case CIMType::REAL64:

set(Array<Real64>(arraySize));

break;

case CIMType::CHAR16:

set(Array<Char16>(arraySize));

break;

case CIMType::STRING:

set(Array<String>(arraySize));

break;

case CIMType::DATETIME:

set(Array<CIMDateTime>(arraySize));

break;

}

else

{

switch (type)

{

case CIMType::BOOLEAN:

set(false);

break;

case CIMType::UINT8:

set(Uint8(0));

break;

case CIMType::SINT8:

set(Sint8(0));

break;

case CIMType::UINT16:

set(Uint16(0));

break;

case CIMType::SINT16:

set(Sint16(0));

break;

case CIMType::UINT32:

set(Uint32(0));

break;

case CIMType::SINT32:

set(Sint32(0));

break;

case CIMType::UINT64:

set(Uint64(0));

break;

case CIMType::SINT64:

set(Sint64(0));

break;

case CIMType::REAL32:

set(Real32(0.0));

break;

case CIMType::REAL64:

set(Real64(0.0));

break;

case CIMType::CHAR16:

set(Char16(0));

break;

case CIMType::STRING:

set(String());

break;

case CIMType::DATETIME:

set(CIMDateTime());

break;

case CIMType::REFERENCE:

set(CIMReference());

break;

}

String CIMValue::toString() const

{

Array<Sint8> out;

if (_isArray)

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

//Choice return empty string or exception out.

if (_rep->_isNull)

return String();

if (_rep->_isArray)

{

switch (_type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

{

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

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

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

{

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

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

out << " ";

}

break;

}

case CIMType::UINT8:

case CIMTYPE_UINT8:

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

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

_rep->_u._uint8Array->size());

break;

case CIMType::SINT8:

case CIMTYPE_SINT8:

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

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

_rep->_u._sint8Array->size());

break;

case CIMType::UINT16:

case CIMTYPE_UINT16:

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

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

_rep->_u._uint16Array->size());

break;

case CIMType::SINT16:

case CIMTYPE_SINT16:

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

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

_rep->_u._sint16Array->size());

break;

case CIMType::UINT32:

case CIMTYPE_UINT32:

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

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

_rep->_u._uint32Array->size());

break;

case CIMType::SINT32:

case CIMTYPE_SINT32:

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

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

_rep->_u._sint32Array->size());

break;

case CIMType::UINT64:

case CIMTYPE_UINT64:

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

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

_rep->_u._uint64Array->size());

break;

case CIMType::SINT64:

case CIMTYPE_SINT64:

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

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

_rep->_u._sint64Array->size());

break;

case CIMType::REAL32:

case CIMTYPE_REAL32:

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

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

_rep->_u._real32Array->size());

break;

case CIMType::REAL64:

case CIMTYPE_REAL64:

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

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

_rep->_u._real64Array->size());

break;

case CIMType::CHAR16:

case CIMTYPE_CHAR16:

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

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

_rep->_u._char16Array->size());

break;

case CIMType::STRING:

case CIMTYPE_STRING:

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

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

_rep->_u._stringArray->size());

break;

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

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

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

_rep->_u._dateTimeArray->size());

break;

case CIMTYPE_REFERENCE:

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

_rep->_u._referenceArray->size());

break;

default:

throw CIMValueInvalidType();

}

else if (_type == CIMType::REFERENCE)

{

return _u._referenceValue->toString();

}

else

{

switch (_type)

switch (_rep->_type)

{

case CIMType::BOOLEAN:

case CIMTYPE_BOOLEAN:

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

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

break;

case CIMTYPE_UINT8:

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

break;

case CIMType::UINT8:

case CIMTYPE_SINT8:

_toXml(out, _u._uint8Value);

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

break;

case CIMType::SINT8:

case CIMTYPE_UINT16:

_toXml(out, _u._sint8Value);

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

break;

case CIMType::UINT16:

case CIMTYPE_SINT16:

_toXml(out, _u._uint16Value);

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

break;

case CIMType::SINT16:

case CIMTYPE_UINT32:

_toXml(out, _u._sint16Value);

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

break;

case CIMType::UINT32:

case CIMTYPE_SINT32:

_toXml(out, _u._uint32Value);

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

break;

case CIMType::SINT32:

case CIMTYPE_UINT64:

_toXml(out, _u._sint32Value);

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

break;

case CIMType::UINT64:

case CIMTYPE_SINT64:

_toXml(out, _u._uint64Value);

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

break;

case CIMType::SINT64:

case CIMTYPE_REAL32:

_toXml(out, _u._sint64Value);

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

break;

case CIMType::REAL32:

case CIMTYPE_REAL64:

_toXml(out, _u._real32Value);

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

break;

case CIMType::REAL64:

case CIMTYPE_CHAR16:

_toXml(out, _u._real64Value);

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

break;

case CIMType::CHAR16:

case CIMTYPE_STRING:

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

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

break;

case CIMType::STRING:

case CIMTYPE_DATETIME:

_toXml(out, *_u._stringValue);

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

break;

case CIMType::DATETIME:

case CIMTYPE_REFERENCE:

_toXml(out, *_u._dateTimeValue);

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

break;

default:

throw CIMValueInvalidType();

}

Line 1906

Line 1677

return out.getData();

}

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

{

return x.equal(y);

}

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

{

return !x.equal(y);

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.11.2.7
changed lines
	Added in v.1.37

No CVS admin address has been configured