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.88 and 1.116

version 1.88, 2003/08/25 15:15:02

version 1.116, 2006/01/30 16:17:08

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

// (carolann_graves@hp.com)

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

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

// Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)

// Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#3103

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

#include <Pegasus/Common/Config.h>

#include <cctype>

#include <cstdio>

#include <cstdlib>

#if defined(PEGASUS_OS_TYPE_UNIX)

#if defined(PEGASUS_OS_TYPE_UNIX) || defined(PEGASUS_OS_VMS)

#include <errno.h>

#endif

#include "CIMName.h"

Line 46

Line 56

#include "CIMObject.h"

#include "CIMParamValue.h"

#include "System.h"

#include "XmlConstants.h"

#ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM

#include "OS400ConvertChar.h"

#endif

// l10n

#include <Pegasus/Common/MessageLoader.h>

#include <Pegasus/Common/AutoPtr.h>

#include "CIMNameUnchecked.h"

#define PEGASUS_SINT64_MIN (PEGASUS_SINT64_LITERAL(0x8000000000000000))

#define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(0xFFFFFFFFFFFFFFFF)

Line 319

Line 332

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

// testStartTagOrEmptyTag()

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

Boolean XmlReader::testStartTagOrEmptyTag(

XmlParser& parser,

XmlEntry& entry)

{

if (!parser.next(entry) ||

(entry.type != XmlEntry::START_TAG &&

entry.type != XmlEntry::EMPTY_TAG))

{

parser.putBack(entry);

return false;

}

return true;

}

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

// testContentOrCData()

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

Line 446

Line 480

#endif

}

return CIMName (name);

return CIMNameUnchecked(name);

}

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

Line 526

Line 560

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

return CIMName();

// KS 200209 This may be temp but we are adding test for form

// CLASSNAME = "" for Wbemservices interoperability. Returns same

// as if attribute did not exist.

if (name.size() == 0)

return CIMName();

if (!CIMName::legal(name))

{

// l10n

Line 556

Line 584

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

// getEmbeddedObjectAttribute()

// <!ENTITY % EmbeddedObject "EMBEDDEDOBJECT (object | instance) #IMPLIED">

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

String XmlReader::getEmbeddedObjectAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* elementName)

{

String embeddedObject;

if (!entry.getAttributeValue("EMBEDDEDOBJECT", embeddedObject))

return String();

// The embeddedObject attribute, if present, must have the string

// value "object" or "instance".

if (!(String::equal(embeddedObject, "object") ||

String::equal(embeddedObject, "instance")

)

{

// l10n

// char buffer[MESSAGE_SIZE];

// sprintf(buffer,

// "Illegal value for %s.EMBEDDEDOBJECT attribute", elementName);

// throw XmlSemanticError(lineNumber, buffer);

char buffer[MESSAGE_SIZE];

sprintf(buffer, "%s.EMBEDDEDOBJECT", elementName);

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

return embeddedObject;

}

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

// getReferenceClassAttribute()

// <!ENTITY % ReferenceClass "REFERENCECLASS CDATA #IMPLIED">

Line 728

Line 802

type = CIMTYPE_REAL64;

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

type = CIMTYPE_REFERENCE;

// PEP 194:

// Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, just a

// Pegasus internal representation of an embedded object, so it won't be found here.

else unrecognizedType = true;

if (unrecognizedType ||

Line 901

Line 978

return true;

}

inline Uint8 _hexCharToNumeric(const char c)

inline Uint8 _xmlReader_hexCharToNumeric(const char c)

{

Uint8 n;

Line 942

Line 1019

}

Uint8 digit1 = _hexCharToNumeric(char(uriString[++i]));

Uint8 digit1 = _xmlReader_hexCharToNumeric(char(uriString[++i]));

Uint8 digit2 = _hexCharToNumeric(char(uriString[++i]));

Uint8 digit2 = _xmlReader_hexCharToNumeric(char(uriString[++i]));

if ( (digit1 > 15) || (digit2 > 15) )

{

// l10n

Line 970

Line 1047

{

// Convert UTF-8 to UTF-16 and return the String

utf8Chars.append('\0');

return String((char *)utf8Chars.getData(),STRING_FLAG_UTF8);

return String((char *)utf8Chars.getData());

}

else

{

Line 1032

Line 1109

x = x << 4;

// Make sure we don't overflow when we add the next digit

Sint64 newDigit = Sint64(_hexCharToNumeric(*p++));

Sint64 newDigit = Sint64(_xmlReader_hexCharToNumeric(*p++));

if (PEGASUS_SINT64_MIN - x > -newDigit)

{

return false;

Line 1152

Line 1229

x = x << 4;

// We can't overflow when we add the next digit

Uint64 newDigit = Uint64(_hexCharToNumeric(*p++));

Uint64 newDigit = Uint64(_xmlReader_hexCharToNumeric(*p++));

if (PEGASUS_UINT64_MAX - x < newDigit)

{

return false;

Line 1245

Line 1322

case CIMTYPE_STRING:

{

return CIMValue(String(valueString, STRING_FLAG_UTF8));

return CIMValue(String(valueString));

}

case CIMTYPE_CHAR16:

Line 1265

Line 1342

}

// Converts UTF-8 to UTF-16

String tmp(valueString, STRING_FLAG_UTF8);

String tmp(valueString);

if (tmp.size() != 1)

{

// l10n

Line 1509

Line 1586

return CIMValue(x);

}

// PEP 194:

// Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, but just a

// Pegasus internal representation of an embedded object. However, this case is

// used when decoding string representations of embedded objects.

case CIMTYPE_OBJECT:

{

CIMObject x;

if (*valueString == '\0')

{

x = CIMObject();

}

else

{

// Convert the non-NULL string to a CIMObject (containing either a

// CIMInstance or a CIMClass).

// First we need to create a new "temporary" XmlParser that is

// just the value of the Embedded Object in String representation.

AutoArrayPtr<char> tmp_buffer(new char[strlen(valueString) + 1]);

strcpy(tmp_buffer.get(), valueString);

XmlParser tmp_parser(tmp_buffer.get());

// The next bit of logic constructs a CIMObject from the Embedded Object String.

// It is similar to the method XmlReader::getValueObjectElement().

CIMInstance cimInstance;

CIMClass cimClass;

if (XmlReader::getInstanceElement(tmp_parser, cimInstance))

{

x = CIMObject(cimInstance);

}

else if (XmlReader::getClassElement(tmp_parser, cimClass))

{

x = CIMObject(cimClass);

}

else

{

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected INSTANCE or CLASS element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",

"Expected INSTANCE or CLASS element"); // change "element" to "embedded object"

throw XmlValidationError(lineNumber, mlParms);

}

// Ok, now we can delete the storage for the temporary XmlParser.

tmp_buffer.reset();

}

return CIMValue(x);

}

default:

break;

}

Line 1527

Line 1659

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

// skipElement()

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

void XmlReader::skipElement(

XmlParser& parser,

XmlEntry& entry)

{

const char * tag_name = entry.text;

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

{

return;

}

while (testStartTagOrEmptyTag(parser, entry))

{

skipElement(parser, entry);

}

if (testContentOrCData(parser, entry))

{

; // skip

}

expectEndTag(parser, tag_name);

return;

}

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

// getValueElement()

// <!ELEMENT VALUE (#PCDATA)>

Line 1544

Line 1706

XmlEntry entry;

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

{

return false;

}

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

Line 1553

Line 1717

if (!empty)

{

if (testContentOrCData(parser, entry))

{

valueString = entry.text;

}

expectEndTag(parser, "VALUE");

}

Line 1614

Line 1780

expectEndTag(parser, "VALUE");

}

str = String(valueString,STRING_FLAG_UTF8);

str = String(valueString);

return true;

}

Line 1751

Line 1917

case CIMTYPE_REAL64:

return StringArrayToValueAux(lineNumber, array, type, (Real64*)0);

// PEP 194:

// Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, but just a

// Pegasus internal representation of an embedded object. However, this case is

// used when decoding string representations of embedded objects.

case CIMTYPE_OBJECT:

return StringArrayToValueAux(lineNumber, array, type, (CIMObject*)0);

default:

break;

}

Line 1960

Line 2133

// Get QUALIFIER element:

XmlEntry entry;

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

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

return false;

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

// Get QUALIFIER.NAME attribute:

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

Line 1985

Line 2160

CIMValue value;

if (empty)

{

value.setNullValue(type, false);

}

else

{

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

!getValueArrayElement(parser, type, value))

{

Line 1994

Line 2175

// Expect </QUALIFIER>:

expectEndTag(parser, "QUALIFIER");

}

// Build qualifier:

Line 2042

Line 2224

// %CIMName;

// %ClassOrigin;

// %Propagated;

// %EmbeddedObject; #IMPLIED

// %CIMType; #REQUIRED>

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

Line 2069

Line 2252

Boolean propagated = getCimBooleanAttribute(

parser.getLine(), entry, "PROPERTY", "PROPAGATED", false, false);

// Get PROPERTY.EMBEDDEDOBJECT attribute:

String embeddedObject = getEmbeddedObjectAttribute(

parser.getLine(), entry, "PROPERTY");

// Get PROPERTY.TYPE attribute:

CIMType type;

Line 2081

Line 2269

if (!empty)

{

// Get qualifiers:

// Get qualifiers. We need to do this before checking for the property as an

// embedded object, because we need to also check for the EmbeddedObject qualifier.

getQualifierElements(parser, property);

}

Boolean embeddedObjectQualifierValue = false;

Uint32 ix = property.findQualifier(CIMName("EmbeddedObject"));

if (ix != PEG_NOT_FOUND)

{

property.getQualifier(ix).getValue().get(embeddedObjectQualifierValue);

}

// If the EMBEDDEDOBJECT attribute is present with value "object"

// or the EmbeddedObject qualifier exists on this property with value "true"

// then

// Convert the EmbeddedObject-encoded string into a CIMObject

if (String::equal(embeddedObject, "object") || embeddedObjectQualifierValue)

{

// The EMBEDDEDOBJECT attribute is only valid on Properties of type string

if (type == CIMTYPE_STRING)

{

type = CIMTYPE_OBJECT;

CIMValue new_value(type, false);

CIMProperty new_property = CIMProperty(name, new_value, 0, CIMName(), classOrigin, propagated);

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

// Copy the qualifiers from the String property to the CIMObject property.

for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)

{

// All properties are copied, including the EmbeddedObject qualifier.

// This way we don't have to keep track to know that the EmbeddedObject

// qualifier needs to be added back during the encode step.

new_property.addQualifier(property.getQualifier(ix));

}

value = new_value;

property = new_property;

}

else

{

// Error -- throw exception

// (the EmbeddedObject attribute may be applied only to entities that have the type String)

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected string type");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

"The EMBEDDEDOBJECT attribute is only valid on string types.");

throw XmlValidationError(parser.getLine(), mlParms);

}

// Continue on to get property value, if not empty.

if (!empty)

{

if (getValueElement(parser, type, value))

property.setValue(value);

expectEndTag(parser, "PROPERTY");

}

Line 2152

Line 2390

// %CIMType; #REQUIRED

// %ArraySize;

// %ClassOrigin;

// %Propagated;>

// %Propagated;

// %EmbeddedObject; #IMPLIED>

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

Line 2186

Line 2425

// Get PROPERTY.CLASSORIGIN attribute:

CIMName classOrigin

CIMName classOrigin = getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");

= getClassOriginAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");

// Get PROPERTY.ARRAY.PROPAGATED

Boolean propagated = getCimBooleanAttribute(

Boolean propagated = getCimBooleanAttribute(parser.getLine()

parser.getLine(), entry, "PROPERTY.ARRAY", "PROPAGATED", false, false);

,entry

,"PROPERTY.ARRAY"

,"PROPAGATED"

,false

,false);

// Get PROPERTY.EMBEDDEDOBJECT attribute:

String embeddedObject = getEmbeddedObjectAttribute(parser.getLine()

,entry

,"PROPERTY.ARRAY");

// Create property:

CIMValue value(type, true, arraySize);

property = CIMProperty(

property = CIMProperty(name, value, arraySize, CIMName(), classOrigin, propagated);

name, value, arraySize, CIMName(), classOrigin, propagated);

if (!empty)

{

// Get qualifiers:

getQualifierElements(parser, property);

}

Boolean embeddedObjectQualifierValue = false;

Uint32 ix = property.findQualifier(CIMName("EmbeddedObject"));

if (ix != PEG_NOT_FOUND)

{

property.getQualifier(ix).getValue().get(embeddedObjectQualifierValue);

}

// If the EMBEDDEDOBJECT attribute is present with value "object"

// or the EmbeddedObject qualifier exists on this property with value "true"

// then

// Convert the EmbeddedObject-encoded string into a CIMObject

if (String::equal(embeddedObject, "object") || embeddedObjectQualifierValue)

{

// The EMBEDDEDOBJECT attribute is only valid on Properties of type string

if (type == CIMTYPE_STRING)

{

type = CIMTYPE_OBJECT;

CIMValue new_value(type, true, arraySize);

CIMProperty new_property = CIMProperty(name, new_value, arraySize, CIMName(), classOrigin, propagated);

// Copy the qualifiers from the String property to the CIMObject property.

for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)

{

// All properties are copied, including the EmbeddedObject qualifier.

// This way we don't have to keep track to know that the EmbeddedObject

// qualifier needs to be added back during the encode step.

new_property.addQualifier(property.getQualifier(ix));

}

value = new_value;

property = new_property;

}

else

{

// Error -- throw exception

// (the EmbeddedObject attribute may be applied only to entities that have the type String)

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected string type");

// Get value:

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

"The EMBEDDEDOBJECT attribute is only valid on string types.");

throw XmlValidationError(parser.getLine(), mlParms);

}

// Continue on to get property array value, if not empty.

// Else not an embedded object, if not empty, get the property array value.

if (!empty)

{

if (getValueArrayElement(parser, type, value))

{

if (arraySize && arraySize != value.getArraySize())

Line 2226

Line 2524

property.setValue(value);

}

expectEndTag(parser, "PROPERTY.ARRAY");

}

Line 2257

Line 2554

throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());

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

host = String(entry.text,STRING_FLAG_UTF8);

host = String(entry.text);

else

{

parser.putBack(entry);

Line 2281

Line 2578

}

host = String(entry.text,STRING_FLAG_UTF8);

host = String(entry.text);

#endif

expectEndTag(parser, "HOST");

return true;

Line 2539

Line 2836

throw XmlException(XmlException::UNCLOSED_TAGS, parser.getLine());

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

value = String(entry.text,STRING_FLAG_UTF8);

value = String(entry.text);

else

parser.putBack(entry);

Line 3557

Line 3854

{

XmlEntry entry;

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

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

return false;

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

Line 3566

Line 3863

cimClass = CIMClass(name, superClass);

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

{

// Get QUALIFIER elements:

getQualifierElements(parser, cimClass);

Line 3584

Line 3884

// Get CLASS end tag:

expectEndTag(parser, "CLASS");

}

return true;

}

Line 3604

Line 3905

{

XmlEntry entry;

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

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

return false;

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

String className = getClassNameAttribute(

parser.getLine(), entry, "INSTANCE");

cimInstance = CIMInstance(className);

if (!empty)

{

// Get QUALIFIER elements:

getQualifierElements(parser, cimInstance);

// Get PROPERTY elements:

GetPropertyElements(parser, cimInstance);

// Get INSTANCE end tag:

expectEndTag(parser, "INSTANCE");

}

return true;

}

Line 3849

Line 4152

Boolean XmlReader::getIMethodResponseStartTag(

XmlParser& parser,

const char*& name)

const char*& name,

Boolean& isEmptyTag)

{

XmlEntry entry;

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

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

return false;

isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);

// Get IMETHODRESPONSE.NAME attribute:

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

Line 3883

Line 4189

Boolean XmlReader::getIParamValueTag(

XmlParser& parser,

const char*& name)

const char*& name,

Boolean& isEmptyTag)

{

XmlEntry entry;

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

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

return false;

isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);

// Get IPARAMVALUE.NAME attribute:

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

Line 3910

Line 4219

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

// rejectNullIParamValue()

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

void XmlReader::rejectNullIParamValue(

XmlParser& parser,

Boolean isEmptyTag,

const char* paramName)

{

if (isEmptyTag)

{

MessageLoaderParms mlParms("Common.XmlReader.INVALID_NULL_IPARAMVALUE",

"A null value is not valid for IPARAMVALUE \"$0\".",

paramName);

throw XmlValidationError(parser.getLine(), mlParms);

}

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

// getBooleanValueElement()

// Get an elements like: "<VALUE>FALSE</VALUE>"

Line 3967

Line 4296

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

// getErrorElement()

// DMTF CR Pending

// <!ELEMENT ERROR EMPTY>

// <!ELEMENT ERROR (INSTANCE*)>

// <!ATTLIST ERROR

// CODE CDATA #REQUIRED

// DESCRIPTION CDATA #IMPLIED>

Line 4028

Line 4357

entry.getAttributeValue("DESCRIPTION", tmpDescription);

if (!empty)

{

while (testStartTagOrEmptyTag(parser, entry))

{

skipElement(parser, entry);

}

expectEndTag(parser, "ERROR");

}

cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription);

return true;

Line 4058

Line 4394

{

object = CIMObject(cimInstance);

}

else if (!XmlReader::getClassElement(parser, cimClass))

else if (XmlReader::getClassElement(parser, cimClass))

{

object = CIMObject(cimClass);

}

Line 4106

Line 4442

else if (!XmlReader::getClassPathElement(parser, reference))

{

// l10n

// l10n 485

// throw XmlValidationError(parser.getLine(),

// "Expected INSTANCEPATH or CLASSPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",

"Expected INSTANCEPATH or CLASSPATH element", "INSTANCEPATH", "CLASSPATH");

"Expected INSTANCEPATH or CLASSPATH element");

throw XmlValidationError(parser.getLine(), mlParms);

}

Line 4193

Line 4529

// throw XmlValidationError(parser.getLine(),

// "Expected LOCALINSTANCEPATH or LOCALCLASSPATH element");

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_LOCALINSTANCEPATH_OR_LOCALCLASSPATH_ELEMENT",

//l10n updated

"Expected LOCALINSTANCEPATH or LOCALCLASSPATH element");

MessageLoaderParms mlParms("Common.XmlConstants.MISSING_ELEMENT_LOCALPATH",

MISSING_ELEMENT_LOCALPATH);

throw XmlValidationError(parser.getLine(), mlParms);

Line 4320

Line 4657

}

return false;

PEGASUS_UNREACHABLE( return false; )

}

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

Line 4407

Line 4744

Boolean XmlReader::getEMethodResponseStartTag(

XmlParser& parser,

const char*& name)

const char*& name,

Boolean& isEmptyTag)

{

XmlEntry entry;

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

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

return false;

isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);

// Get EXPMETHODRESPONSE.NAME attribute:

Line 4511

Line 4851

Boolean XmlReader::getMethodResponseStartTag(

XmlParser& parser,

const char*& name)

const char*& name,

Boolean& isEmptyTag)

{

XmlEntry entry;

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

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

return false;

isEmptyTag = (entry.type == XmlEntry::EMPTY_TAG);

// Get METHODRESPONSE.NAME attribute:

Line 4544

Line 4887

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

// <!ATTLIST PARAMVALUE

// %CIMName;

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

Line 4554

Line 4898

{

XmlEntry entry;

const char* name;

CIMType type;

CIMType type=CIMTYPE_BOOLEAN;

CIMValue value;

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

Line 4577

Line 4921

throw XmlValidationError(parser.getLine(), mlParms);

}

// Get PROPERTY.EMBEDDEDOBJECT

String embeddedObject = getEmbeddedObjectAttribute(

parser.getLine(), entry, "PARAMVALUE");

// Get PARAMVALUE.PARAMTYPE attribute:

Boolean gotType = getCimTypeAttribute(parser.getLine(), entry, type,

"PARAMVALUE", "PARAMTYPE", false);

if (!empty)

if (empty)

{

gotType = false; // Can't distinguish array and non-array types

}

else

{

// Parse VALUE.REFERENCE and VALUE.REFARRAY type

if ( (type == CIMTYPE_REFERENCE) || !gotType )

Line 4617

Line 4969

effectiveType = type;

}

// If the EMBEDDEDOBJECT attribute is present with value "object"

// then

// Convert the EmbeddedObject-encoded string into a CIMObject

if (String::equal(embeddedObject, "object"))

{

// The EMBEDDEDOBJECT attribute is only valid on Parameters of type string

// The type must have been specified.

if (gotType && (type == CIMTYPE_STRING))

{

// Used below by getValueElement() or getValueArrayElement()

effectiveType = CIMTYPE_OBJECT;

}

else

{

// Error -- throw exception

// (the EmbeddedObject attribute may be applied only to entities that have the type String)

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected string type");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

"The EMBEDDEDOBJECT attribute is only valid on string types.");

throw XmlValidationError(parser.getLine(), mlParms);

}

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

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

{

gotType = false; // Can't distinguish array and non-array types

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

}

expectEndTag(parser, "PARAMVALUE");

}

paramValue = CIMParamValue(name, value, gotType);

return true;

Line 4638

Line 5022

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

// <!ATTLIST RETURNVALUE

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

Line 4653

Line 5038

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

return false;

// Get PROPERTY.EMBEDDEDOBJECT

String embeddedObject = getEmbeddedObjectAttribute(

parser.getLine(), entry, "RETURNVALUE");

// Get RETURNVALUE.PARAMTYPE attribute:

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

Line 4693

Line 5083

type = CIMTYPE_STRING;

}

if (String::equal(embeddedObject, "object"))

{

if (gotType && (type == CIMTYPE_STRING))

{

type = CIMTYPE_OBJECT; // Used below by getValueElement()

}

else

{

// Error -- throw exception

// (the EmbeddedObject attribute may be applied only to entities that have the type String)

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected string type");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

"The EMBEDDEDOBJECT attribute is only valid on string types.");

throw XmlValidationError(parser.getLine(), mlParms);

}

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

{

Line 4714

Line 5127

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.88
changed lines
	Added in v.1.116

No CVS admin address has been configured