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

Return to XmlReader.cpp CVS log

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

Diff for /pegasus/src/Pegasus/Common/XmlReader.cpp between version 1.24.2.2 and 1.38

version 1.24.2.2, 2001/09/27 21:57:24

version 1.38, 2002/03/20 17:47:07

Line 25

// Modified By: Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

// Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)

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

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

Line 42

#include "CIMClass.h"

#include "CIMInstance.h"

#include "CIMObject.h"

#include "CIMNamedInstance.h"

#include "CIMParamValue.h"

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

static const Uint32 MESSAGE_SIZE = 128;

Line 262

Line 265

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

// testCimStartTag()

// getCimStartTag()

// <!ELEMENT CIM (MESSAGE|DECLARATION)>

// <!ATTRLIST CIM

Line 271

Line 274

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

void XmlReader::testCimStartTag(XmlParser& parser)

void XmlReader::getCimStartTag(

XmlParser& parser,

const char*& cimVersion,

const char*& dtdVersion)

{

XmlEntry entry;

XmlReader::expectStartTag(parser, entry, "CIM");

const char* cimVersion;

if (!entry.getAttributeValue("CIMVERSION", cimVersion))

throw XmlValidationError(

parser.getLine(), "missing CIM.CIMVERSION attribute");

if (strcmp(cimVersion, "2.0") != 0)

throw XmlValidationError(parser.getLine(),

"CIM.CIMVERSION attribute must be \"2.0\"");

const char* dtdVersion;

if (!entry.getAttributeValue("DTDVERSION", dtdVersion))

throw XmlValidationError(

parser.getLine(), "missing CIM.DTDVERSION attribute");

if (strcmp(dtdVersion, "2.0") != 0)

throw XmlValidationError(parser.getLine(),

"CIM.DTDVERSION attribute must be \"2.0\"");

}

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

// getIsArrayAttribute()

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

Boolean XmlReader::getIsArrayAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* tagName,

Boolean& value)

{

const char* tmp;

if (!entry.getAttributeValue("ISARRAY", tmp))

return false;

if (strcmp(tmp, "true") == 0)

{

value = true;

return true;

}

else if (strcmp(tmp, "false") == 0)

{

value = false;

return true;

}

char buffer[62];

sprintf(buffer, "Bad %s.%s attribute value", "ISARRAY", tagName);

throw XmlSemanticError(lineNumber, buffer);

return false;

}

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

Line 491

Line 451

// getCimTypeAttribute()

// This method can be used to get a TYPE attribute or a PARAMTYPE attribute.

// The only significant difference is that PARAMTYPE may specify a value of

// "reference" type. This method recognizes these attributes by name, and

// does not allow a "TYPE" attribute to be of "reference" type.

// <!ENTITY % ParamType "PARAMTYPE (boolean|string|char16|uint8|sint8

// |reference)">

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

CIMType XmlReader::getCimTypeAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* tagName)

const char* tagName,

const char* attributeName,

Boolean required)

{

const char* typeName;

if (!entry.getAttributeValue("TYPE", typeName))

if (!entry.getAttributeValue(attributeName, typeName))

{

if (required)

{

char message[MESSAGE_SIZE];

sprintf(message, "missing %s.TYPE attribute", tagName);

sprintf(message, "missing %s.%s attribute", tagName, attributeName);

throw XmlValidationError(lineNumber, message);

}

else

{

return CIMType::NONE;

}

CIMType type = CIMType::NONE;

Line 543

Line 521

else if (strcmp(typeName, "reference") == 0)

type = CIMType::REFERENCE;

// ATTN: "reference" is not legal according to the DTD; however, it is

if ((type == CIMType::NONE) ||

// used by the XML version of the CIM schema.

((type == CIMType::REFERENCE) &&

(strcmp(attributeName, "PARAMTYPE") != 0)))

if (type == CIMType::NONE)

{

char message[MESSAGE_SIZE];

sprintf(message, "Illegal value for %s.TYPE attribute", tagName);

sprintf(message, "Illegal value for %s.%s attribute", tagName,

attributeName);

throw XmlSemanticError(lineNumber, message);

}

Line 717

Line 695

const char* last = p;

// Build the Sint64 as a negative number, regardless of the eventual sign

x = -(*first++ - '0');

while (first != last)

x = 10 * x + (*first++ - '0');

{

if (x < -922337203685477580LL /* -(1<<63) / 10 */)

{

return false;

}

x = 10 * x;

Sint64 newDigit = (*first++ - '0');

if (PEGASUS_LLONG_MIN - x > -newDigit)

{

return false;

}

x = x - newDigit;

}

if (negative)

if (!negative)

{

if (x == PEGASUS_LLONG_MIN)

{

return false;

}

x = -x;

}

return true;

}

Line 730

Line 728

// stringToUnsignedInteger

// [ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" )

// [ "+" ] ( positiveDecimalDigit *decimalDigit | "0" )

// ATTN-B: handle conversion from hexadecimal.

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

Line 778

Line 776

const char* last = p;

while (first != last)

x = 10 * x + (*first++ - '0');

{

if (x > 1844674407370955161ULL /* (1<<64 - 1) / 10 */)

{

return false;

}

x = 10 * x;

Uint64 newDigit = (*first++ - '0');

if (18446744073709551615ULL - x < newDigit)

{

return false;

}

x = x + newDigit;

}

return true;

}

Line 787

Line 797

// stringToValue()

// ATTN-C: note that integers are truncated without warning. What should be

// Return: CIMValue. If the string input is zero length creates a CIMValue

// done in this case? In C they are truncated without warning by design.

// with value defined by the type. Else the value is inserted.

// Note that this does not set the CIMValue Null if the string is empty.

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

Line 799

Line 811

{

// ATTN-B: accepting only UTF-8 for now! (affects string and char16):

// If strlen == 0, set to default value for type

if (strlen(valueString)==0)

{

switch (type)

Line 819

Line 833

}

// Create value per type

switch (type)

{

case CIMType::BOOLEAN:

Line 860

Line 875

switch (type)

{

case CIMType::UINT8: return CIMValue(Uint8(x));

case CIMType::UINT8:

case CIMType::UINT16: return CIMValue(Uint16(x));

{

case CIMType::UINT32: return CIMValue(Uint32(x));

if (x >= (Uint64(1)<<8))

{

throw XmlSemanticError(

lineNumber, "Uint8 value out of range");

}

return CIMValue(Uint8(x));

}

case CIMType::UINT16:

{

if (x >= (Uint64(1)<<16))

{

throw XmlSemanticError(

lineNumber, "Uint16 value out of range");

}

return CIMValue(Uint16(x));

}

case CIMType::UINT32:

{

if (x >= (Uint64(1)<<32))

{

throw XmlSemanticError(

lineNumber, "Uint32 value out of range");

}

return CIMValue(Uint32(x));

}

case CIMType::UINT64: return CIMValue(Uint64(x));

default: break;

}

Line 883

Line 922

switch (type)

{

case CIMType::SINT8: return CIMValue(Sint8(x));

case CIMType::SINT8:

case CIMType::SINT16: return CIMValue(Sint16(x));

{

case CIMType::SINT32: return CIMValue(Sint32(x));

if( (x >= (Sint64(1)<<7)) || (x < (-(Sint64(1)<<7))) )

{

throw XmlSemanticError(

lineNumber, "Sint8 value out of range");

}

return CIMValue(Sint8(x));

}

case CIMType::SINT16:

{

if( (x >= (Sint64(1)<<15)) || (x < (-(Sint64(1)<<15))) )

{

throw XmlSemanticError(

lineNumber, "Sint16 value out of range");

}

return CIMValue(Sint16(x));

}

case CIMType::SINT32:

{

if( (x >= (Sint64(1)<<31)) || (x < (-(Sint64(1)<<31))) )

{

throw XmlSemanticError(

lineNumber, "Sint32 value out of range");

}

return CIMValue(Sint32(x));

}

case CIMType::SINT64: return CIMValue(Sint64(x));

default: break;

}

Line 914

Line 977

if (!stringToReal(valueString, x))

throw XmlSemanticError(lineNumber, "Bad real value");

// ATTN-RK-P3-20010319: This value gets truncated.

return CIMValue(Real32(x));

}

Line 941

Line 1005

// <!ELEMENT VALUE (#PCDATA)>

// Return: false if no value element.

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

Boolean XmlReader::getValueElement(

Line 948

Line 1014

CIMType type,

CIMValue& value)

{

// Get VALUE start tag:

// Get VALUE start tag: Return false if no VALUE start Tag

XmlEntry entry;

if (!testStartTagOrEmptyTag(parser, entry, "VALUE"))

Line 1012

Line 1078

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

// getPropertyValue

// Use: Decode property value from getPropertyResponse

// Use: Decode property value from SetProperty request and

// Expect (ERROR|IRETURNVALUE).!ELEMENT VALUE (#PCDATA)>

// GetProperty response.

// PropertyValue is one of:

// PropertyValue:

// <!ELEMENT VALUE.ARRAY (VALUE*)>

// <!ELEMENT VALUE>

// <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|

// <!ELEMENT VALUE.ARRAY (VALUE*)>

// <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|

// INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>

// <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>

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

Boolean XmlReader::getPropertyValue(

XmlParser& parser,

CIMValue& cimValue)

{

//Test for Element value type

// Can not test for value type, so assume String

CIMType type = CIMType::STRING;

const CIMType type = CIMType::STRING;

// Test for VALUE element

if (XmlReader::getValueElement(parser, type, cimValue))

{

//cout << "DEBUG xmlReader::getPropertyValue " << __LINE__

// << " CimValue = " << cimValue.toString << endl;

return true;

}

//Test for Element.array value

// Test for VALUE.ARRAY element

if(XmlReader::getValueArrayElement(parser, type, cimValue))

{

return true;

}

// Test for Value.reference type

// Test for VALUE.REFERENCE element

// ATTN:This returns a different type (CIMReference)

// ATTN: Possibly change to simply return result after

// we figure out the type differences.

CIMReference reference;

if(XmlReader::getValueReferenceElement(parser, reference))

{

cimValue.set(reference);

return true;

}

// Test for VALUE.REFARRAY element

if (XmlReader::getValueReferenceArrayElement(parser, cimValue))

{

return true;

}

return false;

}

Line 1145

Line 1222

// <!ELEMENT VALUE.ARRAY (VALUE*)>

// Return: Boolean. Returns false if there is no VALUE.ARRAY start element

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

Boolean XmlReader::getValueArrayElement(

Line 1152

Line 1231

CIMType type,

CIMValue& value)

{

// Clears any values from the Array. Assumes this is array CIMValue

value.clear();

// Get VALUE.ARRAY open tag:

XmlEntry entry;

Array<const char*> stringArray;

// If no VALUE.ARRAY start tag, return false

if (!testStartTagOrEmptyTag(parser, entry, "VALUE.ARRAY"))

return false;

//ATTN: P1 KS KSTESTNULL - Need to relook at this one.

if (entry.type == XmlEntry::EMPTY_TAG)

return true;

if (entry.type != XmlEntry::EMPTY_TAG)

{

// For each VALUE element:

Array<const char*> stringArray;

while (testStartTagOrEmptyTag(parser, entry, "VALUE"))

{

if (entry.type == XmlEntry::EMPTY_TAG)

Line 1185

Line 1268

}

expectEndTag(parser, "VALUE.ARRAY");

}

value = stringArrayToValue(parser.getLine(), stringArray, type);

return true;

Line 1227

Line 1311

Boolean translatable = getCimBooleanAttribute(

lineNumber, entry, tagName, "TRANSLATABLE", false, false);

Uint32 flavor = 0;

// ATTN: KS P1 5 Mar 2002 Should this not be CIMFlavor::DEFAULTS??

//Uint32 flavor = CIMFlavor::DEFAULTS;

// ATTN-RK-P1-20020307: No, Karl. If you initialize to the defaults,

// you have to unset the default flavors that don't apply. The code

// below only adds qualifiers.

Uint32 flavor = CIMFlavor::NONE;

if (overridable)

flavor |= CIMFlavor::OVERRIDABLE;

Line 1352

Line 1441

// Get VALUE or VALUE.ARRAY element:

// ATTN: KS P1 4 March 2002 - Requires either value or array element or

// generates exception. Correct for spec but means no NULL values on qualifier

// values. Alternative is to set NULL value and continue

CIMValue value;

if (!getValueElement(parser, type, value) &&

Line 1435

Line 1528

CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY");

// Create property:

// Create property: Sets type and !isarray

// ATTN: KS P1 change to use the correct constructor

CIMValue value;

value.setNullValue(type, false);

Line 1448

Line 1542

getQualifierElements(parser, property);

// Get value:

// Get value: Insert value if getValueElement exists (returns True)

if (getValueElement(parser, type, value))

property.setValue(value);

Line 1547

Line 1641

// Create property:

// ATTN: KS P1 4 March 2002 Change to use correct constructor.

// ATTN: KS P3 4 March 2002. Why create extra value. Use same one.

CIMValue nullValue;

nullValue.setNullValue(type, true, arraySize);

property = CIMProperty(

Line 1560

Line 1657

// Get value:

// ATTN: KS P1 4 March 2002. Does not set array type into value.

// ATTN: Thus, if it returns false, the CIMValue is nothing.

CIMValue value;

if (getValueArrayElement(parser, type, value))

Line 1792

Line 1891

// <!ATTLIST KEYVALUE

// VALUETYPE (string|boolean|numeric) 'string'>

// ATTN-B: VALUE.REFERENCE ignored above; can't understand why it is needed!

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

Boolean XmlReader::getKeyValueElement(

Line 1836

Line 1933

// <!ATTLIST KEYBINDING

// %CIMName;>

// ATTN-B: VALUE.REFERENCE ignored above; can't understand why it is needed!

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

Boolean XmlReader::getKeyBindingElement(

Line 1854

Line 1949

name = getCimNameAttribute(parser.getLine(), entry, "KEYBINDING");

if (!getKeyValueElement(parser, type, value))

throw XmlValidationError(parser.getLine(), "Expected KEYVALUE element");

{

CIMReference reference;

if (!getValueReferenceElement(parser, reference))

{

throw XmlValidationError(parser.getLine(),

"Expected KEYVALUE or VALUE.REFERENCE element");

}

type = KeyBinding::REFERENCE;

value = reference.toString();

}

expectEndTag(parser, "KEYBINDING");

return true;

Line 1868

Line 1974

// <!ATTLIST INSTANCENAME

// %ClassName;>

// ATTN-B: VALUE.REFERENCE sub-element not accepted yet.

// Note: An empty key name is used in the keyBinding when the INSTANCENAME is

// specified using a KEYVALUE or a VALUE.REFERENCE.

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

Line 1889

Line 1996

className = getClassNameAttribute(parser.getLine(), entry, "INSTANCENAME");

if (!empty)

if (empty)

{

return true;

}

String name;

KeyBinding::Type type;

String value;

CIMReference reference;

if (getKeyValueElement(parser, type, value))

{

// Use empty key name because none was specified

keyBindings.append(KeyBinding(name, value, type));

}

else if (getValueReferenceElement(parser, reference))

{

// Use empty key name because none was specified

type = KeyBinding::REFERENCE;

value = reference.toString();

keyBindings.append(KeyBinding(name, value, type));

}

else

{

while (getKeyBindingElement(parser, name, value, type))

keyBindings.append(KeyBinding(name, value, type));

}

if (!empty)

expectEndTag(parser, "INSTANCENAME");

}

return true;

}

Line 2153

Line 2277

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

// getValueReferenceArrayElement()

// <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>

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

Boolean XmlReader::getValueReferenceArrayElement(

XmlParser& parser,

CIMValue& value)

{

XmlEntry entry;

Array<CIMReference> referenceArray;

CIMReference reference;

value.clear();

// Get VALUE.REFARRAY open tag:

if (!testStartTagOrEmptyTag(parser, entry, "VALUE.REFARRAY"))

return false;

if (entry.type != XmlEntry::EMPTY_TAG)

{

// For each VALUE.REFERENCE element:

while (getValueReferenceElement(parser, reference))

{

referenceArray.append(reference);

}

expectEndTag(parser, "VALUE.REFARRAY");

}

value.set(referenceArray);

return true;

}

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

// getPropertyReferenceElement()

// <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,(VALUE.REFERENCE)?)>

Line 2385

Line 2548

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

// getParameterReferenceArrayElement()

// <!ELEMENT PARAMETER.REFARRAY (QUALIFIER*)>

// <!ATTLIST PARAMETER.REFARRAY

// %CIMName;

// %ReferenceClass;

// %ArraySize;>

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

Boolean XmlReader::getParameterReferenceArrayElement(

XmlParser& parser,

CIMParameter& parameter)

{

XmlEntry entry;

if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFARRAY"))

return false;

Boolean empty = entry.type == XmlEntry::EMPTY_TAG;

// Get PARAMETER.NAME attribute:

String name = getCimNameAttribute(

parser.getLine(), entry, "PARAMETER.REFARRAY");

// Get PARAMETER.REFERENCECLASS attribute:

String referenceClass = getReferenceClassAttribute(

parser.getLine(), entry, "PARAMETER.REFARRAY");

// Get PARAMETER.ARRAYSIZE attribute:

Uint32 arraySize = 0;

getArraySizeAttribute(parser.getLine(), entry, "PARAMETER.REFARRAY",

arraySize);

// Create parameter:

parameter = CIMParameter(name, CIMType::REFERENCE, true, arraySize,

referenceClass);

if (!empty)

{

getQualifierElements(parser, parameter);

expectEndTag(parser, "PARAMETER.REFARRAY");

}

return true;

}

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

// GetParameterElements()

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

Line 2396

Line 2612

while (XmlReader::getParameterElement(parser, parameter) ||

XmlReader::getParameterArrayElement(parser, parameter) ||

XmlReader::getParameterReferenceElement(parser, parameter))

XmlReader::getParameterReferenceElement(parser, parameter) ||

XmlReader::getParameterReferenceArrayElement(parser, parameter))

{

try

{

Line 2446

Line 2663

// Get ISARRAY attribute:

Boolean isArray = false;

Boolean isArray = getCimBooleanAttribute(

getIsArrayAttribute(

parser.getLine(), entry, "QUALIFIER.DECLARATION", "ISARRAY",

parser.getLine(), entry, "QUALIFIER.DECLARATION", isArray);

false, false);

// Get ARRAYSIZE attribute:

Line 2552

Line 2769

if (!empty)

{

// ATTN-RK-P2-20020219: Decoding algorithm must not depend on the

// ordering of qualifiers and parameters.

getQualifierElements(parser, method);

GetParameterElements(parser, method);

Line 2646

Line 2865

}

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

// getNamedInstanceElement()

// <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME,INSTANCE)>

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

Boolean XmlReader::getNamedInstanceElement(

XmlParser& parser,

CIMNamedInstance& namedInstance)

{

XmlEntry entry;

if (!testStartTag(parser, entry, "VALUE.NAMEDINSTANCE"))

return false;

CIMReference instanceName;

// Get INSTANCENAME elements:

if (!getInstanceNameElement(parser, instanceName))

{

throw XmlValidationError(parser.getLine(),

"expected INSTANCENAME element");

}

CIMInstance instance;

// Get INSTANCE elements:

if (!getInstanceElement(parser, instance))

{

throw XmlValidationError(parser.getLine(),

"expected INSTANCE element");

}

// Get VALUE.NAMEDINSTANCE end tag:

expectEndTag(parser, "VALUE.NAMEDINSTANCE");

namedInstance.set(instanceName, instance);

return true;

}

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

// getObject()

Line 2699

Line 2963

Boolean XmlReader::getMessageStartTag(

XmlParser& parser,

String& id,

const char*& protocolVersion)

String& protocolVersion)

{

XmlEntry entry;

Line 2820

Line 3084

expectContentOrCData(parser, entry);

if (strcmp(entry.text, "TRUE") == 0)

if (CompareNoCase(entry.text, "TRUE") == 0)

result = true;

else if (strcmp(entry.text, "FALSE") == 0)

else if (CompareNoCase(entry.text, "FALSE") == 0)

result = false;

else

throw XmlSemanticError(parser.getLine(),

Line 2949

Line 3213

CIMReference& objectName)

{

String className;

CIMReference instanceName;

if (getClassNameElement(parser, className, false))

{

Line 3049

Line 3312

return true;

}

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

// getMethodCallStartTag()

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

Boolean XmlReader::getMethodCallStartTag(

XmlParser& parser,

const char*& name)

{

XmlEntry entry;

if (!testStartTag(parser, entry, "METHODCALL"))

return false;

// Get METHODCALL.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

throw XmlValidationError(parser.getLine(),

"Missing METHODCALL.NAME attribute");

return true;

}

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

// getMethodResponseStartTag()

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

Boolean XmlReader::getMethodResponseStartTag(

XmlParser& parser,

const char*& name)

{

XmlEntry entry;

if (!testStartTag(parser, entry, "METHODRESPONSE"))

return false;

// Get METHODRESPONSE.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

throw XmlValidationError(parser.getLine(),

"Missing METHODRESPONSE.NAME attribute");

return true;

}

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

// getParamValueElement()

// <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>

// <!ATTLIST PARAMVALUE

// %CIMName;

// %ParamType;>

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

Boolean XmlReader::getParamValueElement(

XmlParser& parser,

CIMParamValue& paramValue)

{

XmlEntry entry;

const char* name;

CIMType type;

CIMValue value;

if (!testStartTagOrEmptyTag(parser, entry, "PARAMVALUE"))

return false;

Boolean empty = entry.type == XmlEntry::EMPTY_TAG;

// Get PARAMVALUE.NAME attribute:

if (!entry.getAttributeValue("NAME", name))

throw XmlValidationError(parser.getLine(),

"Missing PARAMVALUE.NAME attribute");

// Get PARAMVALUE.PARAMTYPE attribute:

type = getCimTypeAttribute(parser.getLine(), entry, "PARAMVALUE",

"PARAMTYPE", false);

if (!empty)

{

// Parse VALUE.REFERENCE and VALUE.REFARRAY type

if ( (type == CIMType::REFERENCE) || (type == CIMType::NONE) )

{

CIMReference reference;

if (XmlReader::getValueReferenceElement(parser, reference))

{

value.set(reference);

type = CIMType::REFERENCE;

}

else if (XmlReader::getValueReferenceArrayElement(parser, value))

{

type = CIMType::REFERENCE;

}

// If type==reference but no VALUE.REFERENCE found, use null value

}

// Parse non-reference value

if ( type != CIMType::REFERENCE )

{

// If we don't know what type the value is, read it as a String

CIMType effectiveType = type;

if ( effectiveType == CIMType::NONE)

{

effectiveType = CIMType::STRING;

}

if ( !XmlReader::getValueArrayElement(parser, effectiveType, value) &&

!XmlReader::getValueElement(parser, effectiveType, value) )

{

value.clear(); // Isn't necessary; should already be cleared

}

expectEndTag(parser, "PARAMVALUE");

}

paramValue = CIMParamValue(name, value, Boolean(type!=CIMType::NONE));

return true;

}

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

// getReturnValueElement()

// <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>

// <!ATTLIST RETURNVALUE

// %ParamType;>

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

Boolean XmlReader::getReturnValueElement(

XmlParser& parser,

CIMValue& returnValue)

{

XmlEntry entry;

CIMType type;

CIMValue value;

if (!testStartTag(parser, entry, "RETURNVALUE"))

return false;

// Get RETURNVALUE.PARAMTYPE attribute:

// NOTE: Array type return values are not allowed (2/20/02)

type = getCimTypeAttribute(parser.getLine(), entry, "RETURNVALUE",

"PARAMTYPE", false);

// Parse VALUE.REFERENCE type

if ( (type == CIMType::REFERENCE) || (type == CIMType::NONE) )

{

CIMReference reference;

if (XmlReader::getValueReferenceElement(parser, reference))

{

returnValue.set(reference);

type = CIMType::REFERENCE;

}

else if (type == CIMType::REFERENCE)

{

throw XmlValidationError(parser.getLine(),

"expected VALUE.REFERENCE element");

}

// Parse non-reference return value

if ( type != CIMType::REFERENCE )

{

// If we don't know what type the value is, read it as a String

if ( type == CIMType::NONE)

{

type = CIMType::STRING;

}

if ( !XmlReader::getValueElement(parser, type, returnValue) )

{

throw XmlValidationError(parser.getLine(),

"expected VALUE element");

}

expectEndTag(parser, "RETURNVALUE");

return true;

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.24.2.2
changed lines
	Added in v.1.38

No CVS admin address has been configured