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

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

version 1.49.4.1, 2004/11/12 17:48:28

Line 1

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

//%2003////////////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

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

// IBM Corp.; EMC 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 29

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

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

Line 37

Line 40

#include "Union.h"

#include "Indentor.h"

#include "XmlWriter.h"

#include "CommonUTF.h"

#include "CIMValueRep.h"

PEGASUS_NAMESPACE_BEGIN

Line 45

Line 51

#undef PEGASUS_ARRAY_T

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

// _toString routines:

Line 68

Line 75

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

{

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

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

out.append(Sint8(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.

char str[6];

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

char* charIN = (char *)&x;

const Uint16 *strsrc = (Uint16 *)charIN;

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

Uint8 *strtgt = (Uint8 *)str;

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

UTF16toUTF8(&strsrc,

endsrc,

&strtgt,

endtgt);

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

}

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

Line 79

Line 106

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

{

out << x.getString();

out << x.toString();

}

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

Line 87

Line 114

out << x.toString();

}

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

{

out << x.toString();

}

template<class T>

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

{

Line 100

Line 132

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

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

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

Line 238

Line 237

set(x);

}

CIMValue::CIMValue(const CIMObject& x)

{

_rep = new CIMValueRep();

set(x);

}

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

{

_rep = new CIMValueRep();

Line 328

Line 333

set(x);

}

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

{

_rep = new CIMValueRep();

set(x);

}

CIMValue::CIMValue(const CIMValue& x)

{

_rep = new CIMValueRep();

Line 356

Line 367

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

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

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

_rep->_u._voidPtr = 0;

if (_rep->_isArray)

{

Line 436

Line 446

_rep->_u._referenceArray =

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

break;

case CIMTYPE_OBJECT:

_rep->_u._cimobjectArray =

new Array<CIMObject>(*(x._rep->_u._cimobjectArray));

break;

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(false);

}

else

{

switch (_rep->_type)

{

case CIMTYPE_NONE:

break;

case CIMTYPE_BOOLEAN:

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

break;

Line 509

Line 522

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

break;

case CIMTYPE_OBJECT:

_rep->_u._cimobjectValue =

new CIMObject(x._rep->_u._cimobjectValue->clone());

break;

// Should never get here. testing complete enum

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(false);

}

//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 (_rep->_isArray)

Line 585

Line 600

delete _rep->_u._referenceArray;

break;

//default:

case CIMTYPE_OBJECT:

//throw CIMValueInvalidType();

delete _rep->_u._cimobjectArray;

break;

default:

PEGASUS_ASSERT(false);

}

else

Line 618

Line 637

case CIMTYPE_REFERENCE:

delete _rep->_u._referenceValue;

break;

//default:

//throw CIMValueInvalidType();

case CIMTYPE_OBJECT:

delete _rep->_u._cimobjectValue;

break;

default:

PEGASUS_ASSERT(false);

}

Line 650

Line 674

switch (_rep->_type)

{

case CIMTYPE_NONE:

return 0;

break;

case CIMTYPE_BOOLEAN:

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

break;

Line 713

Line 733

case CIMTYPE_REFERENCE:

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

break;

// Should never get here. switch on complete enum

default:

case CIMTYPE_OBJECT:

throw CIMValueInvalidType();

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

break;

//default: // Handled below

}

// Unreachable!

Line 730

Line 753

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

{

clear();

if (isArray)

Line 796

Line 818

case CIMTYPE_REFERENCE:

set(Array<CIMObjectPath>(arraySize));

break;

case CIMTYPE_OBJECT:

set(Array<CIMObject>(arraySize));

break;

default:

throw CIMValueInvalidType();

throw TypeMismatchException();

}

else

Line 863

Line 890

case CIMTYPE_REFERENCE:

set(CIMObjectPath());

break;

case CIMTYPE_OBJECT:

set(CIMObject());

break;

default:

throw CIMValueInvalidType();

throw TypeMismatchException();

}

Line 994

Line 1026

_rep->_isNull = false;

}

void CIMValue::set(const CIMObject& x)

{

clear();

if (x.isUninitialized()) {

// Don't need to clone since null CIMObjects aren't shared when created.

// Doesn't work anyway, clone() throws an exception if null.

_rep->_u._cimobjectValue = new CIMObject(x);

}

else {

_rep->_u._cimobjectValue = new CIMObject(x.clone());

}

_rep->_type = CIMTYPE_OBJECT;

_rep->_isNull = false;

}

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

{

clear();

Line 1129

Line 1176

_rep->_isNull = false;

}

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

{

clear();

_rep->_u._cimobjectArray = new Array<CIMObject>(x);

_rep->_type = CIMTYPE_OBJECT;

_rep->_isArray = true;

_rep->_isNull = false;

}

void CIMValue::get(Boolean& x) const

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

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

}

void CIMValue::get(Uint8& x) const

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = _rep->_u._uint8Value;

}

void CIMValue::get(Sint8& x) const

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = _rep->_u._sint8Value;

}

void CIMValue::get(Uint16& x) const

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = _rep->_u._uint16Value;

}

void CIMValue::get(Sint16& x) const

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = _rep->_u._sint16Value;

}

void CIMValue::get(Uint32& x) const

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = _rep->_u._uint32Value;

}

void CIMValue::get(Sint32& x) const

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = _rep->_u._sint32Value;

}

void CIMValue::get(Uint64& x) const

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = _rep->_u._uint64Value;

}

void CIMValue::get(Sint64& x) const

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = _rep->_u._sint64Value;

}

void CIMValue::get(Real32& x) const

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = _rep->_u._real32Value;

}

void CIMValue::get(Real64& x) const

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = _rep->_u._real64Value;

}

void CIMValue::get(Char16& x) const

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = _rep->_u._char16Value;

}

void CIMValue::get(String& x) const

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._stringValue;

}

void CIMValue::get(CIMDateTime& x) const

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._dateTimeValue;

}

void CIMValue::get(CIMObjectPath& x) const

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._referenceValue;

}

void CIMValue::get(CIMObject& x) const

{

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

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._cimobjectValue;

}

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

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._booleanArray;

}

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

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._uint8Array;

}

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

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._sint8Array;

}

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

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._uint16Array;

}

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

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._sint16Array;

}

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

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._uint32Array;

}

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

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._sint32Array;

}

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

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._uint64Array;

}

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

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._sint64Array;

}

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

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._real32Array;

}

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

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._real64Array;

}

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

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._char16Array;

}

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

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._stringArray;

}

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 TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._dateTimeArray;

}

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

{

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

throw TypeMismatch();

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._referenceArray;

}

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

{

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

throw TypeMismatchException();

if (!_rep->_isNull)

x = *_rep->_u._cimobjectArray;

}

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

{

if (!typeCompatible(x))

Line 1442

Line 1544

case CIMTYPE_REFERENCE:

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

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

case CIMTYPE_OBJECT:

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

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

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(false);

}

else

Line 1497

Line 1604

return *_rep->_u._referenceValue ==

*x._rep->_u._referenceValue;

case CIMTYPE_OBJECT:

return (*_rep->_u._cimobjectValue).identical((*x._rep->_u._cimobjectValue));

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(false);

}

Line 1600

Line 1710

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

break;

case CIMTYPE_OBJECT:

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

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

break;

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(false);

}

else

Line 1668

Line 1783

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

break;

case CIMTYPE_OBJECT:

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

break;

default:

throw CIMValueInvalidType();

PEGASUS_ASSERT(false);

}

Legend:

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

No CVS admin address has been configured