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.37 and 1.68

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

version 1.68, 2006/07/18 16:34:03

Line 1

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

//%2006////////////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// IBM Corp.; EMC Corporation, The Open Group.

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; Symantec Corporation; The Open Group.

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

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

Line 27

Line 35

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

// Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

// Adriann Schuur (schuur@de.ibm.com) PEP 164

// Dave Sudlik, IBM (dsudlik@us.ibm.com)

// David Dillard, VERITAS Software Corp.

// (david.dillard@veritas.com)

// Mike Brasher, Inova Europe (mike-brasher@austin.rr.com)

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

Line 34

Line 47

#include <cstdio>

#include <cctype>

#include "CIMValue.h"

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

#include "CIMInstance.h"

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

#include "Union.h"

#include "Indentor.h"

#include "XmlWriter.h"

#include "CommonUTF.h"

#include "CIMValueRep.h"

#include "Config.h"

#include "CIMType.h"

#include "String.h"

#include "CIMDateTime.h"

#include "CIMObjectPath.h"

#include "CIMObject.h"

#include "Array.h"

#include <Pegasus/Common/PegasusAssert.h>

PEGASUS_NAMESPACE_BEGIN

Line 44

Line 70

# include "ArrayImpl.h"

#undef PEGASUS_ARRAY_T

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

// ATTN: By getting a CIMObject from a CIMValue, the client of CIMValue can

// modify the internals of that CIMObject and thus change what CIMValue

// _toString routines:

// itself refers to. There are two solutions: clone() at ever juncture or

// force CIMValue to make its own unique copy when the client calls get()

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

// to get a CIMObject.

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

{

XmlWriter::append(out, x);

}

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

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

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

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

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

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

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

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

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

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

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

{

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

out.append(Sint8(x));

}

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

{

out << x;

}

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

{

out << x.getString();

}

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

{

out << x.toString();

}

template<class T>

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

{

while (size--)

{

_toString(out, *p++);

out << " ";

}

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

//==============================================================================

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

// _toString() routines:

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

//==============================================================================

CIMValue::CIMValue()

{

_rep = new CIMValueRep();

}

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

{

_rep = new CIMValueRep();

setNullValue(type, isArray, arraySize);

}

CIMValue::CIMValue(Boolean x)

{

_rep = new CIMValueRep();

set(x);

}

CIMValue::CIMValue(Uint8 x)

{

_rep = new CIMValueRep();

set(x);

}

CIMValue::CIMValue(Sint8 x)

{

_rep = new CIMValueRep();

set(x);

}

CIMValue::CIMValue(Uint16 x)

{

_rep = new CIMValueRep();

set(x);

}

CIMValue::CIMValue(Sint16 x)

inline void _toString(Buffer& out, Boolean x)

{

_rep = new CIMValueRep();

XmlWriter::append(out, x);

set(x);

}

CIMValue::CIMValue(Uint32 x)

inline void _toString(Buffer& out, Uint8 x)

{

_rep = new CIMValueRep();

XmlWriter::append(out, Uint32(x));

set(x);

}

CIMValue::CIMValue(Sint32 x)

inline void _toString(Buffer& out, Sint8 x)

{

_rep = new CIMValueRep();

XmlWriter::append(out, Sint32(x));

set(x);

}

CIMValue::CIMValue(Uint64 x)

inline void _toString(Buffer& out, Uint16 x)

{

_rep = new CIMValueRep();

XmlWriter::append(out, Uint32(x));

set(x);

}

CIMValue::CIMValue(Sint64 x)

inline void _toString(Buffer& out, Sint16 x)

{

_rep = new CIMValueRep();

XmlWriter::append(out, Sint32(x));

set(x);

}

CIMValue::CIMValue(Real32 x)

inline void _toString(Buffer& out, Uint32 x)

{

_rep = new CIMValueRep();

XmlWriter::append(out, x);

set(x);

}

CIMValue::CIMValue(Real64 x)

inline void _toString(Buffer& out, Sint32 x)

{

_rep = new CIMValueRep();

XmlWriter::append(out, x);

set(x);

}

CIMValue::CIMValue(const Char16& x)

inline void _toString(Buffer& out, Uint64 x)

{

_rep = new CIMValueRep();

XmlWriter::append(out, x);

set(x);

}

CIMValue::CIMValue(const String& x)

inline void _toString(Buffer& out, Sint64 x)

{

_rep = new CIMValueRep();

XmlWriter::append(out, x);

set(x);

}

CIMValue::CIMValue(const CIMDateTime& x)

inline void _toString(Buffer& out, Real32 x)

{

_rep = new CIMValueRep();

XmlWriter::append(out, Real64(x));

set(x);

}

CIMValue::CIMValue(const CIMObjectPath& x)

inline void _toString(Buffer& out, Real64 x)

{

_rep = new CIMValueRep();

XmlWriter::append(out, x);

set(x);

}

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

inline void _toString(Buffer& out, Char16 x)

{

_rep = new CIMValueRep();

// We need to convert the Char16 to UTF8 then append the UTF8

set(x);

// character into the array.

}

// NOTE: The UTF8 character could be several bytes long.

// WARNING: This function will put in replacement character for

// all characters that have surogate pairs.

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

char str[6];

{

memset(str,0x00,sizeof(str));

_rep = new CIMValueRep();

char* charIN = (char *)&x;

set(x);

}

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

const Uint16 *strsrc = (Uint16 *)charIN;

{

Uint16 *endsrc = (Uint16 *)&charIN[1];

_rep = new CIMValueRep();

set(x);

}

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

Uint8 *strtgt = (Uint8 *)str;

{

Uint8 *endtgt = (Uint8 *)&str[5];

_rep = new CIMValueRep();

set(x);

}

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

UTF16toUTF8(&strsrc, endsrc, &strtgt, endtgt);

{

out.append(str, UTF_8_COUNT_TRAIL_BYTES(str[0]) +1);

_rep = new CIMValueRep();

set(x);

}

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

inline void _toString(Buffer& out, const String& x)

{

_rep = new CIMValueRep();

out << x;

set(x);

}

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

{

_rep = new CIMValueRep();

set(x);

}

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

{

_rep = new CIMValueRep();

set(x);

}

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

{

_rep = new CIMValueRep();

set(x);

}

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

inline void _toString(Buffer& out, const CIMDateTime& x)

{

_rep = new CIMValueRep();

out << x.toString();

set(x);

}

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

inline void _toString(Buffer& out, const CIMObjectPath& x)

{

_rep = new CIMValueRep();

out << x.toString();

set(x);

}

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

inline void _toString(Buffer& out, const CIMObject& x)

{

_rep = new CIMValueRep();

out << x.toString();

set(x);

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

inline void _toString(Buffer& out, const CIMInstance& x)

{

_rep = new CIMValueRep();

out << CIMObject(x).toString();

set(x);

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

template<class T>

void _toString(Buffer& out, const T* p, Uint32 size)

{

_rep = new CIMValueRep();

while (size--)

set(x);

}

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

{

_rep = new CIMValueRep();

_toString(out, *p++);

set(x);

out.append(' ');

}

CIMValue::CIMValue(const CIMValue& x)

{

_rep = new CIMValueRep();

assign(x);

}

CIMValue::~CIMValue()

//==============================================================================

{

clear();

// CIMValueRep

delete _rep;

}

//==============================================================================

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

CIMValueRep CIMValueRep::_emptyRep((int*)0);

{

assign(x);

return *this;

}

void CIMValue::assign(const CIMValue& x)

void CIMValueRep::release()

{

if (this == &x)

if (isArray)

return;

clear();

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

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

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

_rep->_u._voidPtr = 0;

if (_rep->_isArray)

{

switch (_rep->_type)

switch (type)

{

case CIMTYPE_BOOLEAN:

_rep->_u._booleanArray =

CIMValueType<Boolean>::destructArray(this);

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

break;

case CIMTYPE_UINT8:

_rep->_u._uint8Array =

CIMValueType<Uint8>::destructArray(this);

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

break;

case CIMTYPE_SINT8:

_rep->_u._sint8Array =

CIMValueType<Sint8>::destructArray(this);

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

break;

case CIMTYPE_UINT16:

_rep->_u._uint16Array =

CIMValueType<Uint16>::destructArray(this);

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

break;

case CIMTYPE_SINT16:

_rep->_u._sint16Array =

CIMValueType<Sint16>::destructArray(this);

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

break;

case CIMTYPE_UINT32:

_rep->_u._uint32Array =

CIMValueType<Uint32>::destructArray(this);

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

break;

case CIMTYPE_SINT32:

_rep->_u._sint32Array =

CIMValueType<Sint32>::destructArray(this);

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

break;

case CIMTYPE_UINT64:

_rep->_u._uint64Array =

CIMValueType<Uint64>::destructArray(this);

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

break;

case CIMTYPE_SINT64:

_rep->_u._sint64Array =

CIMValueType<Sint64>::destructArray(this);

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

break;

case CIMTYPE_REAL32:

_rep->_u._real32Array =

CIMValueType<Real32>::destructArray(this);

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

break;

case CIMTYPE_REAL64:

_rep->_u._real64Array =

CIMValueType<Real64>::destructArray(this);

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

break;

case CIMTYPE_CHAR16:

_rep->_u._char16Array =

CIMValueType<Char16>::destructArray(this);

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

break;

case CIMTYPE_STRING:

_rep->_u._stringArray =

CIMValueType<String>::destructArray(this);

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

break;

case CIMTYPE_DATETIME:

_rep->_u._dateTimeArray =

CIMValueType<CIMDateTime>::destructArray(this);

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

break;

case CIMTYPE_REFERENCE:

_rep->_u._referenceArray =

CIMValueType<CIMObjectPath>::destructArray(this);

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

break;

default:

throw CIMValueInvalidType();

case CIMTYPE_OBJECT:

CIMValueType<CIMObject>::destructArray(this);

break;

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

CIMValueType<CIMInstance>::destructArray(this);

break;

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

}

else

{

switch (_rep->_type)

switch (type)

{

case CIMTYPE_NONE:

break;

case CIMTYPE_BOOLEAN:

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

break;

case CIMTYPE_UINT8:

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

break;

case CIMTYPE_SINT8:

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

break;

case CIMTYPE_UINT16:

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

break;

case CIMTYPE_SINT16:

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

break;

case CIMTYPE_UINT32:

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

break;

case CIMTYPE_SINT32:

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

break;

case CIMTYPE_UINT64:

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

break;

case CIMTYPE_SINT64:

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

break;

case CIMTYPE_REAL32:

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

break;

case CIMTYPE_REAL64:

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

break;

case CIMTYPE_CHAR16:

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

break;

case CIMTYPE_STRING:

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

CIMValueType<String>::destruct(this);

break;

case CIMTYPE_DATETIME:

_rep->_u._dateTimeValue =

CIMValueType<CIMDateTime>::destruct(this);

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

break;

case CIMTYPE_REFERENCE:

_rep->_u._referenceValue =

CIMValueType<CIMObjectPath>::destruct(this);

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

break;

// Should never get here. testing complete enum

case CIMTYPE_OBJECT:

default:

CIMValueType<CIMObject>::destruct(this);

throw CIMValueInvalidType();

break;

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

CIMValueType<CIMInstance>::destruct(this);

break;

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

}

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

// CIMValue

void CIMValue::clear()

//==============================================================================

static inline void _release(CIMValueRep*& rep)

{

if (_rep->_isArray)

if (rep->refs.get() == 1)

rep->release();

else

{

switch (_rep->_type)

CIMValueRep::unref(rep);

rep = new CIMValueRep;

}

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

{

_rep = new CIMValueRep;

switch (type)

{

case CIMTYPE_BOOLEAN:

delete _rep->_u._booleanArray;

CIMValueType<Boolean>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_UINT8:

delete _rep->_u._uint8Array;

CIMValueType<Uint8>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_SINT8:

delete _rep->_u._sint8Array;

CIMValueType<Sint8>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_UINT16:

delete _rep->_u._uint16Array;

CIMValueType<Uint16>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_SINT16:

delete _rep->_u._sint16Array;

CIMValueType<Sint16>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_UINT32:

delete _rep->_u._uint32Array;

CIMValueType<Uint32>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_SINT32:

delete _rep->_u._sint32Array;

CIMValueType<Sint32>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_UINT64:

delete _rep->_u._uint64Array;

CIMValueType<Uint64>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_SINT64:

delete _rep->_u._sint64Array;

CIMValueType<Sint64>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_REAL32:

delete _rep->_u._real32Array;

CIMValueType<Real32>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_REAL64:

delete _rep->_u._real64Array;

CIMValueType<Real64>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_CHAR16:

delete _rep->_u._char16Array;

CIMValueType<Char16>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_STRING:

delete _rep->_u._stringArray;

CIMValueType<String>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_DATETIME:

delete _rep->_u._dateTimeArray;

CIMValueType<CIMDateTime>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_REFERENCE:

delete _rep->_u._referenceArray;

CIMValueType<CIMObjectPath>::setNull(_rep, type, isArray,arraySize);

break;

case CIMTYPE_OBJECT:

CIMValueType<CIMObject>::setNull(_rep, type, isArray, arraySize);

break;

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

CIMValueType<CIMInstance>::setNull(_rep, type, isArray, arraySize);

break;

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

//default:

default:

//throw CIMValueInvalidType();

PEGASUS_ASSERT(0);

}

else

CIMValue::CIMValue(Boolean x)

{

switch (_rep->_type)

_rep = new CIMValueRep;

CIMValueType<Boolean>::set(_rep, x);

}

CIMValue::CIMValue(Uint8 x)

{

case CIMTYPE_BOOLEAN:

_rep = new CIMValueRep;

case CIMTYPE_UINT8:

CIMValueType<Uint8>::set(_rep, x);

case CIMTYPE_SINT8:

}

case CIMTYPE_UINT16:

case CIMTYPE_SINT16:

case CIMTYPE_UINT32:

case CIMTYPE_SINT32:

case CIMTYPE_UINT64:

case CIMTYPE_SINT64:

case CIMTYPE_REAL32:

case CIMTYPE_REAL64:

case CIMTYPE_CHAR16:

break;

case CIMTYPE_STRING:

CIMValue::CIMValue(Sint8 x)

delete _rep->_u._stringValue;

{

break;

_rep = new CIMValueRep;

CIMValueType<Sint8>::set(_rep, x);

}

case CIMTYPE_DATETIME:

CIMValue::CIMValue(Uint16 x)

delete _rep->_u._dateTimeValue;

{

break;

_rep = new CIMValueRep;

CIMValueType<Uint16>::set(_rep, x);

}

CIMValue::CIMValue(Sint16 x)

{

_rep = new CIMValueRep;

CIMValueType<Sint16>::set(_rep, x);

}

CIMValue::CIMValue(Uint32 x)

{

_rep = new CIMValueRep;

CIMValueType<Uint32>::set(_rep, x);

}

CIMValue::CIMValue(Sint32 x)

{

_rep = new CIMValueRep;

CIMValueType<Sint32>::set(_rep, x);

}

CIMValue::CIMValue(Uint64 x)

{

_rep = new CIMValueRep;

CIMValueType<Uint64>::set(_rep, x);

}

CIMValue::CIMValue(Sint64 x)

{

_rep = new CIMValueRep;

CIMValueType<Sint64>::set(_rep, x);

}

CIMValue::CIMValue(Real32 x)

{

_rep = new CIMValueRep;

CIMValueType<Real32>::set(_rep, x);

}

CIMValue::CIMValue(Real64 x)

{

_rep = new CIMValueRep;

CIMValueType<Real64>::set(_rep, x);

}

CIMValue::CIMValue(const Char16& x)

{

_rep = new CIMValueRep;

CIMValueType<Char16>::set(_rep, x);

}

CIMValue::CIMValue(const String& x)

{

_rep = new CIMValueRep;

CIMValueType<String>::set(_rep, x);

}

CIMValue::CIMValue(const CIMDateTime& x)

{

_rep = new CIMValueRep;

CIMValueType<CIMDateTime>::set(_rep, x);

}

CIMValue::CIMValue(const CIMObjectPath& x)

{

_rep = new CIMValueRep;

CIMValueType<CIMObjectPath>::set(_rep, x);

}

CIMValue::CIMValue(const CIMObject& x)

{

if (x.isUninitialized())

{

// Bug 3373, throw exception if uninitialized object is passed to set().

throw UninitializedObjectException();

}

_rep = new CIMValueRep;

CIMValueType<CIMObject>::set(_rep, x.clone());

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

CIMValue::CIMValue(const CIMInstance& x)

{

if (x.isUninitialized())

{

// Bug 3373, throw exception if uninitialized object is passed to set().

throw UninitializedObjectException();

}

case CIMTYPE_REFERENCE:

_rep = new CIMValueRep;

delete _rep->_u._referenceValue;

CIMValueType<CIMInstance>::set(_rep, x.clone());

break;

//default:

//throw CIMValueInvalidType();

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

{

_rep = new CIMValueRep;

CIMValueType<Boolean>::setArray(_rep, x);

}

_rep->reset();

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

{

_rep = new CIMValueRep;

CIMValueType<Uint8>::setArray(_rep, x);

}

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

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

{

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

_rep = new CIMValueRep;

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

CIMValueType<Sint8>::setArray(_rep, x);

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

}

Boolean CIMValue::isArray() const

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

{

return _rep->_isArray;

_rep = new CIMValueRep;

CIMValueType<Uint16>::setArray(_rep, x);

}

Boolean CIMValue::isNull() const

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

{

return _rep->_isNull;

_rep = new CIMValueRep;

CIMValueType<Sint16>::setArray(_rep, x);

}

Uint32 CIMValue::getArraySize() const

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

{

if (!_rep->_isArray)

_rep = new CIMValueRep;

return 0;

CIMValueType<Uint32>::setArray(_rep, x);

}

switch (_rep->_type)

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

{

case CIMTYPE_NONE:

_rep = new CIMValueRep;

return 0;

CIMValueType<Sint32>::setArray(_rep, x);

break;

}

case CIMTYPE_BOOLEAN:

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

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

{

break;

_rep = new CIMValueRep;

CIMValueType<Uint64>::setArray(_rep, x);

}

case CIMTYPE_UINT8:

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

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

{

break;

_rep = new CIMValueRep;

CIMValueType<Sint64>::setArray(_rep, x);

}

case CIMTYPE_SINT8:

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

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

{

break;

_rep = new CIMValueRep;

CIMValueType<Real32>::setArray(_rep, x);

}

case CIMTYPE_UINT16:

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

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

{

break;

_rep = new CIMValueRep;

CIMValueType<Real64>::setArray(_rep, x);

}

case CIMTYPE_SINT16:

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

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

{

break;

_rep = new CIMValueRep;

CIMValueType<Char16>::setArray(_rep, x);

}

case CIMTYPE_UINT32:

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

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

{

break;

_rep = new CIMValueRep;

CIMValueType<String>::setArray(_rep, x);

}

case CIMTYPE_SINT32:

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

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

{

break;

_rep = new CIMValueRep;

CIMValueType<CIMDateTime>::setArray(_rep, x);

}

case CIMTYPE_UINT64:

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

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

{

break;

_rep = new CIMValueRep;

CIMValueType<CIMObjectPath>::setArray(_rep, x);

}

case CIMTYPE_SINT64:

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

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

{

break;

Array<CIMObject> tmp;

case CIMTYPE_REAL32:

for (Uint32 i = 0, n = x.size(); i < n; i++)

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

{

break;

if (x[i].isUninitialized())

{

// Bug 3373, throw exception on uninitialized object.

_rep = &CIMValueRep::_emptyRep;

throw UninitializedObjectException();

}

case CIMTYPE_REAL64:

tmp.append(x[i].clone());

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

}

break;

case CIMTYPE_CHAR16:

_rep = new CIMValueRep;

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

CIMValueType<CIMObject>::setArray(_rep, tmp);

break;

}

case CIMTYPE_STRING:

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

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

break;

{

Array<CIMInstance> tmp;

case CIMTYPE_DATETIME:

for (Uint32 i = 0, n = x.size(); i < n; i++)

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

{

break;

if (x[i].isUninitialized())

{

// Bug 3373, throw exception on uninitialized object.

_rep = &CIMValueRep::_emptyRep;

throw UninitializedObjectException();

}

case CIMTYPE_REFERENCE:

tmp.append(x[i].clone());

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

break;

// Should never get here. switch on complete enum

default:

throw CIMValueInvalidType();

}

_rep = new CIMValueRep;

CIMValueType<CIMInstance>::setArray(_rep, tmp);

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

// Unreachable!

void CIMValue::clear()

PEGASUS_ASSERT(false);

{

return 0;

CIMValueRep::unref(_rep);

_rep = &CIMValueRep::_emptyRep;

}

CIMType CIMValue::getType() const

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

{

if (_rep != x._rep)

{

return CIMType(_rep->_type);

CIMValueRep::unref(_rep);

CIMValueRep::ref(_rep = x._rep);

}

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

return *this;

}

void CIMValue::assign(const CIMValue& x)

{

if (_rep != x._rep)

{

CIMValueRep::unref(_rep);

CIMValueRep::ref(_rep = x._rep);

}

clear();

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

{

return (_rep->type == x._rep->type && _rep->isArray == x._rep->isArray);

}

if (isArray)

Uint32 CIMValue::getArraySize() const

{

switch (type)

if (!_rep->isArray)

return 0;

switch (_rep->type)

{

case CIMTYPE_BOOLEAN:

set(Array<Boolean>(arraySize));

return CIMValueType<Boolean>::arraySize(_rep);

break;

case CIMTYPE_UINT8:

set(Array<Uint8>(arraySize));

return CIMValueType<Uint8>::arraySize(_rep);

break;

case CIMTYPE_SINT8:

set(Array<Sint8>(arraySize));

return CIMValueType<Sint8>::arraySize(_rep);

break;

case CIMTYPE_UINT16:

set(Array<Uint16>(arraySize));

return CIMValueType<Uint16>::arraySize(_rep);

break;

case CIMTYPE_SINT16:

set(Array<Sint16>(arraySize));

return CIMValueType<Sint16>::arraySize(_rep);

break;

case CIMTYPE_UINT32:

set(Array<Uint32>(arraySize));

return CIMValueType<Uint32>::arraySize(_rep);

break;

case CIMTYPE_SINT32:

set(Array<Sint32>(arraySize));

return CIMValueType<Sint32>::arraySize(_rep);

break;

case CIMTYPE_UINT64:

set(Array<Uint64>(arraySize));

return CIMValueType<Uint64>::arraySize(_rep);

break;

case CIMTYPE_SINT64:

set(Array<Sint64>(arraySize));

return CIMValueType<Sint64>::arraySize(_rep);

break;

case CIMTYPE_REAL32:

set(Array<Real32>(arraySize));

return CIMValueType<Real32>::arraySize(_rep);

break;

case CIMTYPE_REAL64:

set(Array<Real64>(arraySize));

return CIMValueType<Real64>::arraySize(_rep);

break;

case CIMTYPE_CHAR16:

set(Array<Char16>(arraySize));

return CIMValueType<Char16>::arraySize(_rep);

break;

case CIMTYPE_STRING:

set(Array<String>(arraySize));

return CIMValueType<String>::arraySize(_rep);

break;

case CIMTYPE_DATETIME:

set(Array<CIMDateTime>(arraySize));

return CIMValueType<CIMDateTime>::arraySize(_rep);

break;

case CIMTYPE_REFERENCE:

set(Array<CIMObjectPath>(arraySize));

return CIMValueType<CIMObjectPath>::arraySize(_rep);

break;

case CIMTYPE_OBJECT:

return CIMValueType<CIMObject>::arraySize(_rep);

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

return CIMValueType<CIMInstance>::arraySize(_rep);

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(0);

}

return 0;

}

else

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

{

// Release any memory:

_release(_rep);

// Set the null value:

switch (type)

{

case CIMTYPE_BOOLEAN:

set(false);

CIMValueType<Boolean>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_UINT8:

set(Uint8(0));

CIMValueType<Uint8>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_SINT8:

set(Sint8(0));

CIMValueType<Sint8>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_UINT16:

set(Uint16(0));

CIMValueType<Uint16>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_SINT16:

set(Sint16(0));

CIMValueType<Sint16>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_UINT32:

set(Uint32(0));

CIMValueType<Uint32>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_SINT32:

set(Sint32(0));

CIMValueType<Sint32>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_UINT64:

set(Uint64(0));

CIMValueType<Uint64>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_SINT64:

set(Sint64(0));

CIMValueType<Sint64>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_REAL32:

set(Real32(0.0));

CIMValueType<Real32>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_REAL64:

set(Real64(0.0));

CIMValueType<Real64>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_CHAR16:

set(Char16(0));

CIMValueType<Char16>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_STRING:

set(String());

CIMValueType<String>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_DATETIME:

set(CIMDateTime());

CIMValueType<CIMDateTime>::setNull(_rep, type, isArray, arraySize);

break;

case CIMTYPE_REFERENCE:

set(CIMObjectPath());

CIMValueType<CIMObjectPath>::setNull(_rep, type, isArray,arraySize);

break;

case CIMTYPE_OBJECT:

CIMValueType<CIMObject>::setNull(_rep, type, isArray, arraySize);

break;

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

CIMValueType<CIMInstance>::setNull(_rep, type, isArray, arraySize);

break;

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(0);

}

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

// because the set functions sets the _isNull.

_rep->_isNull = true;

}

void CIMValue::set(Boolean x)

{

clear();

_release(_rep);

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

CIMValueType<Boolean>::set(_rep, x);

_rep->_type = CIMTYPE_BOOLEAN;

_rep->_isNull = false;

}

void CIMValue::set(Uint8 x)

{

clear();

_release(_rep);

_rep->_u._uint8Value = x;

CIMValueType<Uint8>::set(_rep, x);

_rep->_type = CIMTYPE_UINT8;

_rep->_isNull = false;

}

void CIMValue::set(Sint8 x)

{

clear();

_release(_rep);

_rep->_u._sint8Value = x;

CIMValueType<Sint8>::set(_rep, x);

_rep->_type = CIMTYPE_SINT8;

_rep->_isNull = false;

}

void CIMValue::set(Uint16 x)

{

clear();

_release(_rep);

_rep->_u._uint16Value = x;

CIMValueType<Uint16>::set(_rep, x);

_rep->_type = CIMTYPE_UINT16;

_rep->_isNull = false;

}

void CIMValue::set(Sint16 x)

{

clear();

_release(_rep);

_rep->_u._sint16Value = x;

CIMValueType<Sint16>::set(_rep, x);

_rep->_type = CIMTYPE_SINT16;

_rep->_isNull = false;

}

void CIMValue::set(Uint32 x)

{

clear();

_release(_rep);

_rep->_u._uint32Value = x;

CIMValueType<Uint32>::set(_rep, x);

_rep->_type = CIMTYPE_UINT32;

_rep->_isNull = false;

}

void CIMValue::set(Sint32 x)

{

clear();

_release(_rep);

_rep->_u._sint32Value = x;

CIMValueType<Sint32>::set(_rep, x);

_rep->_type = CIMTYPE_SINT32;

_rep->_isNull = false;

}

void CIMValue::set(Uint64 x)

{

clear();

_release(_rep);

_rep->_u._uint64Value = x;

CIMValueType<Uint64>::set(_rep, x);

_rep->_type = CIMTYPE_UINT64;

_rep->_isNull = false;

}

void CIMValue::set(Sint64 x)

{

clear();

_release(_rep);

_rep->_u._sint64Value = x;

CIMValueType<Sint64>::set(_rep, x);

_rep->_type = CIMTYPE_SINT64;

_rep->_isNull = false;

}

void CIMValue::set(Real32 x)

{

clear();

_release(_rep);

_rep->_u._real32Value = x;

CIMValueType<Real32>::set(_rep, x);

_rep->_type = CIMTYPE_REAL32;

_rep->_isNull = false;

}

void CIMValue::set(Real64 x)

{

clear();

_release(_rep);

_rep->_u._real64Value = x;

CIMValueType<Real64>::set(_rep, x);

_rep->_type = CIMTYPE_REAL64;

_rep->_isNull = false;

}

void CIMValue::set(const Char16& x)

{

clear();

_release(_rep);

_rep->_u._char16Value = x;

CIMValueType<Char16>::set(_rep, x);

_rep->_type = CIMTYPE_CHAR16;

_rep->_isNull = false;

}

void CIMValue::set(const String& x)

{

clear();

_release(_rep);

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

CIMValueType<String>::set(_rep, x);

_rep->_type = CIMTYPE_STRING;

_rep->_isNull = false;

}

void CIMValue::set(const CIMDateTime& x)

{

clear();

_release(_rep);

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

CIMValueType<CIMDateTime>::set(_rep, x);

_rep->_type = CIMTYPE_DATETIME;

_rep->_isNull = false;

}

void CIMValue::set(const CIMObjectPath& x)

{

clear();

_release(_rep);

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

CIMValueType<CIMObjectPath>::set(_rep, x);

_rep->_type = CIMTYPE_REFERENCE;

}

_rep->_isNull = false;

void CIMValue::set(const CIMObject& x)

{

if (x.isUninitialized())

{

// Bug 3373, throw exception on uninitialized object.

throw UninitializedObjectException();

}

_release(_rep);

CIMValueType<CIMObject>::set(_rep, x.clone());

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

void CIMValue::set(const CIMInstance& x)

{

if (x.isUninitialized())

{

// Bug 3373, throw exception on uninitialized object.

throw UninitializedObjectException();

}

_release(_rep);

CIMValueType<CIMInstance>::set(_rep, x.clone());

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

{

clear();

_release(_rep);

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

CIMValueType<Boolean>::setArray(_rep, x);

_rep->_type = CIMTYPE_BOOLEAN;

_rep->_isArray = true;

_rep->_isNull = false;

}

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

{

clear();

_release(_rep);

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

CIMValueType<Uint8>::setArray(_rep, x);

_rep->_type = CIMTYPE_UINT8;

_rep->_isArray = true;

_rep->_isNull = false;

}

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

{

clear();

_release(_rep);

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

CIMValueType<Sint8>::setArray(_rep, x);

_rep->_type = CIMTYPE_SINT8;

_rep->_isArray = true;

_rep->_isNull = false;

}

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

{

clear();

_release(_rep);

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

CIMValueType<Uint16>::setArray(_rep, x);

_rep->_type = CIMTYPE_UINT16;

_rep->_isArray = true;

_rep->_isNull = false;

}

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

{

clear();

_release(_rep);

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

CIMValueType<Sint16>::setArray(_rep, x);

_rep->_type = CIMTYPE_SINT16;

_rep->_isArray = true;

_rep->_isNull = false;

}

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

{

clear();

_release(_rep);

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

CIMValueType<Uint32>::setArray(_rep, x);

_rep->_type = CIMTYPE_UINT32;

_rep->_isArray = true;

_rep->_isNull = false;

}

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

{

clear();

_release(_rep);

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

CIMValueType<Sint32>::setArray(_rep, x);

_rep->_type = CIMTYPE_SINT32;

_rep->_isArray = true;

_rep->_isNull = false;

}

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

{

clear();

_release(_rep);

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

CIMValueType<Uint64>::setArray(_rep, x);

_rep->_type = CIMTYPE_UINT64;

_rep->_isArray = true;

_rep->_isNull = false;

}

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

{

clear();

_release(_rep);

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

CIMValueType<Sint64>::setArray(_rep, x);

_rep->_type = CIMTYPE_SINT64;

_rep->_isArray = true;

_rep->_isNull = false;

}

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

{

clear();

_release(_rep);

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

CIMValueType<Real32>::setArray(_rep, x);

_rep->_type = CIMTYPE_REAL32;

_rep->_isArray = true;

_rep->_isNull = false;

}

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

{

clear();

_release(_rep);

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

CIMValueType<Real64>::setArray(_rep, x);

_rep->_type = CIMTYPE_REAL64;

_rep->_isArray = true;

_rep->_isNull = false;

}

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

{

clear();

_release(_rep);

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

CIMValueType<Char16>::setArray(_rep, x);

_rep->_type = CIMTYPE_CHAR16;

_rep->_isArray = true;

_rep->_isNull = false;

}

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

{

clear();

_release(_rep);

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

CIMValueType<String>::setArray(_rep, x);

_rep->_type = CIMTYPE_STRING;

_rep->_isArray = true;

_rep->_isNull = false;

}

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

{

clear();

_release(_rep);

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

CIMValueType<CIMDateTime>::setArray(_rep, x);

_rep->_type = CIMTYPE_DATETIME;

_rep->_isArray = true;

_rep->_isNull = false;

}

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

{

clear();

_release(_rep);

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

CIMValueType<CIMObjectPath>::setArray(_rep, x);

_rep->_type = CIMTYPE_REFERENCE;

}

_rep->_isArray = true;

_rep->_isNull = false;

void CIMValue::set(const Array<CIMObject>& a)

{

Array<CIMObject> tmp;

for (Uint32 i = 0, n = a.size(); i < n; i++)

{

if (a[i].isUninitialized())

{

// Bug 3373, throw exception on uninitialized object.

throw UninitializedObjectException();

}

tmp.append(a[i].clone());

}

_release(_rep);

CIMValueType<CIMObject>::setArray(_rep, tmp);

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

void CIMValue::set(const Array<CIMInstance>& a)

{

Array<CIMInstance> tmp;

for (Uint32 i = 0, n = a.size(); i < n; i++)

{

if (a[i].isUninitialized())

{

// Bug 3373, throw exception on uninitialized object.

throw UninitializedObjectException();

}

tmp.append(a[i].clone());

}

_release(_rep);

CIMValueType<CIMInstance>::setArray(_rep, tmp);

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

void CIMValue::get(Boolean& x) const

{

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

if (_rep->type != CIMTYPE_BOOLEAN || _rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

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

if (!_rep->isNull)

x = CIMValueType<Boolean>::ref(_rep);

}

void CIMValue::get(Uint8& x) const

{

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

if (_rep->type != CIMTYPE_UINT8 || _rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _rep->_u._uint8Value;

if (!_rep->isNull)

x = CIMValueType<Uint8>::ref(_rep);

}

void CIMValue::get(Sint8& x) const

{

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

if (_rep->type != CIMTYPE_SINT8 || _rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _rep->_u._sint8Value;

if (!_rep->isNull)

x = CIMValueType<Sint8>::ref(_rep);

}

void CIMValue::get(Uint16& x) const

{

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

if (_rep->type != CIMTYPE_UINT16 || _rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _rep->_u._uint16Value;

if (!_rep->isNull)

x = CIMValueType<Uint16>::ref(_rep);

}

void CIMValue::get(Sint16& x) const

{

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

if (_rep->type != CIMTYPE_SINT16 || _rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _rep->_u._sint16Value;

if (!_rep->isNull)

x = CIMValueType<Sint16>::ref(_rep);

}

void CIMValue::get(Uint32& x) const

{

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

if (_rep->type != CIMTYPE_UINT32 || _rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _rep->_u._uint32Value;

if (!_rep->isNull)

x = CIMValueType<Uint32>::ref(_rep);

}

void CIMValue::get(Sint32& x) const

{

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

if (_rep->type != CIMTYPE_SINT32 || _rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _rep->_u._sint32Value;

if (!_rep->isNull)

x = CIMValueType<Sint32>::ref(_rep);

}

void CIMValue::get(Uint64& x) const

{

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

if (_rep->type != CIMTYPE_UINT64 || _rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _rep->_u._uint64Value;

if (!_rep->isNull)

x = CIMValueType<Uint64>::ref(_rep);

}

void CIMValue::get(Sint64& x) const

{

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

if (_rep->type != CIMTYPE_SINT64 || _rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _rep->_u._sint64Value;

if (!_rep->isNull)

x = CIMValueType<Sint64>::ref(_rep);

}

void CIMValue::get(Real32& x) const

{

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

if (_rep->type != CIMTYPE_REAL32 || _rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _rep->_u._real32Value;

if (!_rep->isNull)

x = CIMValueType<Real32>::ref(_rep);

}

void CIMValue::get(Real64& x) const

{

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

if (_rep->type != CIMTYPE_REAL64 || _rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _rep->_u._real64Value;

if (!_rep->isNull)

x = CIMValueType<Real64>::ref(_rep);

}

void CIMValue::get(Char16& x) const

{

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

if (_rep->type != CIMTYPE_CHAR16 || _rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = _rep->_u._char16Value;

if (!_rep->isNull)

x = CIMValueType<Char16>::ref(_rep);

}

void CIMValue::get(String& x) const

{

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

if (_rep->type != CIMTYPE_STRING || _rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_rep->_u._stringValue;

if (!_rep->isNull)

x = CIMValueType<String>::ref(_rep);

}

void CIMValue::get(CIMDateTime& x) const

{

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

if (_rep->type != CIMTYPE_DATETIME || _rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_rep->_u._dateTimeValue;

if (!_rep->isNull)

x = CIMValueType<CIMDateTime>::ref(_rep);

}

void CIMValue::get(CIMObjectPath& x) const

{

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

if (_rep->type != CIMTYPE_REFERENCE || _rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->isNull)

x = CIMValueType<CIMObjectPath>::ref(_rep);

}

void CIMValue::get(CIMObject& x) const

{

if (_rep->type != CIMTYPE_OBJECT || _rep->isArray)

throw TypeMismatchException();

x = *_rep->_u._referenceValue;

if (!_rep->isNull)

// We have to clone our own unique copy since we are about to

// return an object to the caller that he can modify; thereby,

// changing the one we refer to as well.

x = CIMValueType<CIMObject>::ref(_rep).clone();

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

void CIMValue::get(CIMInstance& x) const

{

if (_rep->type != CIMTYPE_INSTANCE || _rep->isArray)

throw TypeMismatchException();

if (!_rep->isNull)

{

// We have to clone our own unique copy since we are about to

// return an object to the caller that he can modify; thereby,

// changing the one we refer to as well.

x = CIMValueType<CIMInstance>::ref(_rep).clone();

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

{

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

if (_rep->type != CIMTYPE_BOOLEAN || !_rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_rep->_u._booleanArray;

if (!_rep->isNull)

x = CIMValueType<Boolean>::aref(_rep);

}

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

{

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

if (_rep->type != CIMTYPE_UINT8 || !_rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_rep->_u._uint8Array;

if (!_rep->isNull)

x = CIMValueType<Uint8>::aref(_rep);

}

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

{

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

if (_rep->type != CIMTYPE_SINT8 || !_rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_rep->_u._sint8Array;

if (!_rep->isNull)

x = CIMValueType<Sint8>::aref(_rep);

}

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

{

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

if (_rep->type != CIMTYPE_UINT16 || !_rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_rep->_u._uint16Array;

if (!_rep->isNull)

x = CIMValueType<Uint16>::aref(_rep);

}

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

{

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

if (_rep->type != CIMTYPE_SINT16 || !_rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_rep->_u._sint16Array;

if (!_rep->isNull)

x = CIMValueType<Sint16>::aref(_rep);

}

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

{

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

if (_rep->type != CIMTYPE_UINT32 || !_rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_rep->_u._uint32Array;

if (!_rep->isNull)

x = CIMValueType<Uint32>::aref(_rep);

}

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

{

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

if (_rep->type != CIMTYPE_SINT32 || !_rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_rep->_u._sint32Array;

if (!_rep->isNull)

x = CIMValueType<Sint32>::aref(_rep);

}

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

{

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

if (_rep->type != CIMTYPE_UINT64 || !_rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_rep->_u._uint64Array;

if (!_rep->isNull)

x = CIMValueType<Uint64>::aref(_rep);

}

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

{

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

if (_rep->type != CIMTYPE_SINT64 || !_rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_rep->_u._sint64Array;

if (!_rep->isNull)

x = CIMValueType<Sint64>::aref(_rep);

}

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

{

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

if (_rep->type != CIMTYPE_REAL32 || !_rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_rep->_u._real32Array;

if (!_rep->isNull)

x = CIMValueType<Real32>::aref(_rep);

}

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

{

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

if (_rep->type != CIMTYPE_REAL64 || !_rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_rep->_u._real64Array;

if (!_rep->isNull)

x = CIMValueType<Real64>::aref(_rep);

}

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

{

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

if (_rep->type != CIMTYPE_CHAR16 || !_rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_rep->_u._char16Array;

if (!_rep->isNull)

x = CIMValueType<Char16>::aref(_rep);

}

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

{

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

if (_rep->type != CIMTYPE_STRING || !_rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

x = *_rep->_u._stringArray;

if (!_rep->isNull)

x = CIMValueType<String>::aref(_rep);

}

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

{

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

if (_rep->type != CIMTYPE_DATETIME || !_rep->isArray)

throw TypeMismatchException();

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

throw TypeMismatch();

x = *_rep->_u._dateTimeArray;

if (!_rep->isNull)

x = CIMValueType<CIMDateTime>::aref(_rep);

}

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

{

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

if (_rep->type != CIMTYPE_REFERENCE || !_rep->isArray)

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->isNull)

x = CIMValueType<CIMObjectPath>::aref(_rep);

}

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

{

if (_rep->type != CIMTYPE_OBJECT || !_rep->isArray)

throw TypeMismatchException();

if (!_rep->isNull)

{

x.clear();

x = *_rep->_u._referenceArray;

// We have to clone our own unique copy since we are about to

// return an object to the caller that he can modify; thereby,

// changing the one we refer to as well.

for (Uint32 i = 0, n = CIMValueType<CIMObject>::arraySize(_rep); i < n; i++)

{

x.append(CIMValueType<CIMObject>::aref(_rep)[i].clone());

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

{

if (_rep->type != CIMTYPE_INSTANCE || !_rep->isArray)

throw TypeMismatchException();

if (!_rep->isNull)

{

x.clear();

// We have to clone our own unique copy since we are about to

// return an object to the caller that he can modify; thereby,

// changing the one we refer to as well.

for (Uint32 i = 0, n = CIMValueType<CIMInstance>::arraySize(_rep); i < n; i++)

{

x.append(CIMValueType<CIMInstance>::aref(_rep)[i].clone());

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

{

if (!typeCompatible(x))

return false;

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

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

return false;

if (_rep->_isArray)

if (_rep->isArray)

{

switch (_rep->_type)

switch (_rep->type)

{

case CIMTYPE_BOOLEAN:

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

return CIMValueType<Boolean>::equalArray(_rep, x._rep);

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

case CIMTYPE_UINT8:

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

return CIMValueType<Uint8>::equalArray(_rep, x._rep);

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

case CIMTYPE_SINT8:

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

return CIMValueType<Sint8>::equalArray(_rep, x._rep);

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

case CIMTYPE_UINT16:

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

return CIMValueType<Uint16>::equalArray(_rep, x._rep);

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

case CIMTYPE_SINT16:

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

return CIMValueType<Sint16>::equalArray(_rep, x._rep);

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

case CIMTYPE_UINT32:

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

return CIMValueType<Uint32>::equalArray(_rep, x._rep);

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

case CIMTYPE_SINT32:

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

return CIMValueType<Sint32>::equalArray(_rep, x._rep);

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

case CIMTYPE_UINT64:

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

return CIMValueType<Uint64>::equalArray(_rep, x._rep);

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

case CIMTYPE_SINT64:

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

return CIMValueType<Sint64>::equalArray(_rep, x._rep);

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

case CIMTYPE_REAL32:

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

return CIMValueType<Real32>::equalArray(_rep, x._rep);

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

case CIMTYPE_REAL64:

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

return CIMValueType<Real64>::equalArray(_rep, x._rep);

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

case CIMTYPE_CHAR16:

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

return CIMValueType<Char16>::equalArray(_rep, x._rep);

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

case CIMTYPE_STRING:

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

return CIMValueType<String>::equalArray(_rep, x._rep);

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

case CIMTYPE_DATETIME:

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

return CIMValueType<CIMDateTime>::equalArray(_rep, x._rep);

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

case CIMTYPE_REFERENCE:

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

return CIMValueType<CIMObjectPath>::equalArray(_rep, x._rep);

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

case CIMTYPE_OBJECT:

return CIMValueType<CIMObject>::equalArray(_rep, x._rep);

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

return CIMValueType<CIMInstance>::equalArray(_rep, x._rep);

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(0);

}

else

{

switch (_rep->_type)

switch (_rep->type)

{

case CIMTYPE_BOOLEAN:

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

return CIMValueType<Boolean>::equal(_rep, x._rep);

case CIMTYPE_UINT8:

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

return CIMValueType<Uint8>::equal(_rep, x._rep);

case CIMTYPE_SINT8:

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

return CIMValueType<Sint8>::equal(_rep, x._rep);

case CIMTYPE_UINT16:

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

return CIMValueType<Uint16>::equal(_rep, x._rep);

case CIMTYPE_SINT16:

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

return CIMValueType<Sint16>::equal(_rep, x._rep);

case CIMTYPE_UINT32:

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

return CIMValueType<Uint32>::equal(_rep, x._rep);

case CIMTYPE_SINT32:

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

return CIMValueType<Sint32>::equal(_rep, x._rep);

case CIMTYPE_UINT64:

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

return CIMValueType<Uint64>::equal(_rep, x._rep);

case CIMTYPE_SINT64:

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

return CIMValueType<Sint64>::equal(_rep, x._rep);

case CIMTYPE_REAL32:

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

return CIMValueType<Real32>::equal(_rep, x._rep);

case CIMTYPE_REAL64:

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

return CIMValueType<Real64>::equal(_rep, x._rep);

case CIMTYPE_CHAR16:

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

return CIMValueType<Char16>::equal(_rep, x._rep);

case CIMTYPE_STRING:

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

return CIMValueType<String>::equal(_rep, x._rep);

*x._rep->_u._stringValue);

case CIMTYPE_DATETIME:

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

return CIMValueType<CIMDateTime>::equal(_rep, x._rep);

case CIMTYPE_REFERENCE:

return *_rep->_u._referenceValue ==

return CIMValueType<CIMObjectPath>::equal(_rep, x._rep);

*x._rep->_u._referenceValue;

case CIMTYPE_OBJECT:

return CIMValueType<CIMObject>::ref(_rep).identical(

CIMValueType<CIMObject>::ref(x._rep));

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

return CIMValueType<CIMInstance>::ref(_rep).identical(

CIMValueType<CIMInstance>::ref(x._rep));

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(0);

}

// Unreachable!

return false;

}

String CIMValue::toString() const

{

Array<Sint8> out;

Buffer out;

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

//Choice return empty string or exception out.

if (_rep->_isNull)

if (_rep->isNull)

return String();

if (_rep->_isArray)

if (_rep->isArray)

{

switch (_rep->_type)

switch (_rep->type)

{

case CIMTYPE_BOOLEAN:

{

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

const Array<Boolean>& a = CIMValueType<Boolean>::aref(_rep);

Uint32 size = a.size();

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

{

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

_toString(out, a[i]);

out << " ";

out.append(' ');

}

break;

}

case CIMTYPE_UINT8:

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

{

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

const Array<Uint8>& a = CIMValueType<Uint8>::aref(_rep);

_toString(out, a.getData(), a.size());

break;

}

case CIMTYPE_SINT8:

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

{

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

const Array<Sint8>& a = CIMValueType<Sint8>::aref(_rep);

_toString(out, a.getData(), a.size());

break;

}

case CIMTYPE_UINT16:

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

{

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

const Array<Uint16>& a = CIMValueType<Uint16>::aref(_rep);

_toString(out, a.getData(), a.size());

break;

}

case CIMTYPE_SINT16:

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

{

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

const Array<Sint16>& a = CIMValueType<Sint16>::aref(_rep);

_toString(out, a.getData(), a.size());

break;

}

case CIMTYPE_UINT32:

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

{

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

const Array<Uint32>& a = CIMValueType<Uint32>::aref(_rep);

_toString(out, a.getData(), a.size());

break;

}

case CIMTYPE_SINT32:

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

{

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

const Array<Sint32>& a = CIMValueType<Sint32>::aref(_rep);

_toString(out, a.getData(), a.size());

break;

}

case CIMTYPE_UINT64:

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

{

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

const Array<Uint64>& a = CIMValueType<Uint64>::aref(_rep);

_toString(out, a.getData(), a.size());

break;

}

case CIMTYPE_SINT64:

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

{

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

const Array<Sint64>& a = CIMValueType<Sint64>::aref(_rep);

_toString(out, a.getData(), a.size());

break;

}

case CIMTYPE_REAL32:

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

{

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

const Array<Real32>& a = CIMValueType<Real32>::aref(_rep);

_toString(out, a.getData(), a.size());

break;

}

case CIMTYPE_REAL64:

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

{

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

const Array<Real64>& a = CIMValueType<Real64>::aref(_rep);

_toString(out, a.getData(), a.size());

break;

}

case CIMTYPE_CHAR16:

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

{

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

const Array<Char16>& a = CIMValueType<Char16>::aref(_rep);

_toString(out, a.getData(), a.size());

break;

}

case CIMTYPE_STRING:

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

{

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

const Array<String>& a = CIMValueType<String>::aref(_rep);

_toString(out, a.getData(), a.size());

break;

}

case CIMTYPE_DATETIME:

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

{

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

const Array<CIMDateTime>& a =

CIMValueType<CIMDateTime>::aref(_rep);

_toString(out, a.getData(), a.size());

break;

}

case CIMTYPE_REFERENCE:

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

{

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

const Array<CIMObjectPath>& a =

CIMValueType<CIMObjectPath>::aref(_rep);

_toString(out, a.getData(), a.size());

break;

}

case CIMTYPE_OBJECT:

{

const Array<CIMObject>& a = CIMValueType<CIMObject>::aref(_rep);

_toString(out, a.getData(), a.size());

break;

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

{

const Array<CIMInstance>& a =

CIMValueType<CIMInstance>::aref(_rep);

_toString(out, a.getData(), a.size());

break;

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(0);

}

else

{

switch (_rep->_type)

switch (_rep->type)

{

case CIMTYPE_BOOLEAN:

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

_toString(out, CIMValueType<Boolean>::ref(_rep));

break;

case CIMTYPE_UINT8:

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

_toString(out, CIMValueType<Uint8>::ref(_rep));

break;

case CIMTYPE_SINT8:

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

_toString(out, CIMValueType<Sint8>::ref(_rep));

break;

case CIMTYPE_UINT16:

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

_toString(out, CIMValueType<Uint16>::ref(_rep));

break;

case CIMTYPE_SINT16:

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

_toString(out, CIMValueType<Sint16>::ref(_rep));

break;

case CIMTYPE_UINT32:

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

_toString(out, CIMValueType<Uint32>::ref(_rep));

break;

case CIMTYPE_SINT32:

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

_toString(out, CIMValueType<Sint32>::ref(_rep));

break;

case CIMTYPE_UINT64:

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

_toString(out, CIMValueType<Uint64>::ref(_rep));

break;

case CIMTYPE_SINT64:

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

_toString(out, CIMValueType<Sint64>::ref(_rep));

break;

case CIMTYPE_REAL32:

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

_toString(out, CIMValueType<Real32>::ref(_rep));

break;

case CIMTYPE_REAL64:

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

_toString(out, CIMValueType<Real64>::ref(_rep));

break;

case CIMTYPE_CHAR16:

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

_toString(out, CIMValueType<Char16>::ref(_rep));

break;

case CIMTYPE_STRING:

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

_toString(out, CIMValueType<String>::ref(_rep));

break;

case CIMTYPE_DATETIME:

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

_toString(out, CIMValueType<CIMDateTime>::ref(_rep));

break;

case CIMTYPE_REFERENCE:

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

_toString(out, CIMValueType<CIMObjectPath>::ref(_rep));

break;

case CIMTYPE_OBJECT:

_toString(out, CIMValueType<CIMObject>::ref(_rep));

break;

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

_toString(out, CIMValueType<CIMInstance>::ref(_rep));

break;

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(0);

}

out.append('\0');

return out.getData();

}

#ifdef PEGASUS_USE_DEPRECATED_INTERFACES

CIMValue::CIMValue(char x)

{

_rep = new CIMValueRep;

CIMValueType<Sint8>::set(_rep, (Sint8)x);

}

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

{

_rep = new CIMValueRep;

Array<Sint8> tmp((Sint8*)x.getData(), x.size());

CIMValueType<Sint8>::setArray(_rep, tmp);

}

void CIMValue::set(char x)

{

set(static_cast<Sint8>(x));

}

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

{

set(*reinterpret_cast<const Array<Sint8>*>(&x));

}

void CIMValue::get(char& x) const

{

get(*reinterpret_cast<Sint8*>(&x));

}

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

{

get(*reinterpret_cast<Array<Sint8>*>(&x));

}

#endif /* PEGASUS_USE_DEPRECATED_INTERFACES */

void CIMValue::_get(const String*& data, Uint32& size) const

{

const Array<String>& a = CIMValueType<String>::aref(_rep);

data = a.getData();

size = a.size();

}

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

{

Legend:

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

No CVS admin address has been configured