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.92 and 1.115.2.2

version 1.92, 2003/10/16 23:25:03

version 1.115.2.2, 2006/02/10 16:09:39

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 52

Line 62

#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 320

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 447

Line 480

#endif

}

return CIMName (name);

return CIMNameUnchecked(name);

}

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

Line 527

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 557

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 729

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 902

Line 978

return true;

}

static inline Uint8 _hexCharToNumeric(const char c)

inline Uint8 _xmlReader_hexCharToNumeric(const char c)

{

Uint8 n;

Line 943

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 971

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 1033

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 1153

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 1246

Line 1322

case CIMTYPE_STRING:

{

return CIMValue(String(valueString, STRING_FLAG_UTF8));

return CIMValue(String(valueString));

}

case CIMTYPE_CHAR16:

Line 1266

Line 1342

}

// Converts UTF-8 to UTF-16

String tmp(valueString, STRING_FLAG_UTF8);

String tmp(valueString);

if (tmp.size() != 1)

{

// l10n

Line 1510

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:

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

{

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

{

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

if(type == CIMTYPE_INSTANCE)

return CIMValue(cimInstance);

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

x = CIMObject(cimInstance);

}

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

{

x = CIMObject(cimClass);

}

else

{

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected INSTANCE or CLASS element");

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

if(type == CIMTYPE_OBJECT)

{

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",

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

throw XmlValidationError(lineNumber, mlParms);

}

else

{

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

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

throw XmlValidationError(lineNumber, mlParms);

}

#else

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",

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

throw XmlValidationError(lineNumber, mlParms);

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

}

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

tmp_buffer.reset();

}

return CIMValue(x);

}

default:

break;

}

Line 1528

Line 1679

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

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

Line 1726

XmlEntry entry;

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

{

return false;

}

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

Line 1554

Line 1737

if (!empty)

{

if (testContentOrCData(parser, entry))

{

valueString = entry.text;

}

expectEndTag(parser, "VALUE");

}

Line 1615

Line 1800

expectEndTag(parser, "VALUE");

}

str = String(valueString,STRING_FLAG_UTF8);

str = String(valueString);

return true;

}

Line 1752

Line 1937

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

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

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

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

default:

break;

}

Line 1961

Line 2157

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

Line 2184

CIMValue value;

if (empty)

{

value.setNullValue(type, false);

}

else

{

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

!getValueArrayElement(parser, type, value))

{

Line 1995

Line 2199

// Expect </QUALIFIER>:

expectEndTag(parser, "QUALIFIER");

}

// Build qualifier:

Line 2043

Line 2248

// %CIMName;

// %ClassOrigin;

// %Propagated;

// %EmbeddedObject; #IMPLIED

// %CIMType; #REQUIRED>

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

Line 2070

Line 2276

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 2082

Line 2293

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

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

String embeddedInstanceQualifierValue;

ix = property.findQualifier(CIMName("EmbeddedInstance"));

if (ix != PEG_NOT_FOUND)

{

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

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

Boolean isEmbeddedObject = String::equal(embeddedObject, "object") ||

embeddedObjectQualifierValue;

Boolean isEmbeddedInstance = String::equal(embeddedObject, "instance") ||

embeddedInstanceQualifierValue.size() > 0;

if (isEmbeddedObject || isEmbeddedInstance)

{

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

if (type == CIMTYPE_STRING)

{

if(isEmbeddedObject)

type = CIMTYPE_OBJECT;

else

type = CIMTYPE_INSTANCE;

CIMValue new_value(type, false);

CIMProperty new_property = CIMProperty(name, new_value, 0, 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");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

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

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

}

#else

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

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

if (!empty)

{

if (getValueElement(parser, type, value))

property.setValue(value);

expectEndTag(parser, "PROPERTY");

}

Line 2153

Line 2467

// %CIMType; #REQUIRED

// %ArraySize;

// %ClassOrigin;

// %Propagated;>

// %Propagated;

// %EmbeddedObject; #IMPLIED>

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

Line 2187

Line 2502

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

}

// Get value:

Boolean embeddedObjectQualifierValue = false;

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

if (ix != PEG_NOT_FOUND)

{

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

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

String embeddedInstanceQualifierValue;

ix = property.findQualifier(CIMName("EmbeddedInstance"));

if (ix != PEG_NOT_FOUND)

{

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

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

Boolean isEmbeddedObject = String::equal(embeddedObject, "object") ||

embeddedObjectQualifierValue;

Boolean isEmbeddedInstance = String::equal(embeddedObject, "instance") ||

embeddedInstanceQualifierValue.size() > 0;

if (isEmbeddedObject || isEmbeddedInstance)

{

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

if (type == CIMTYPE_STRING)

{

if(isEmbeddedObject)

type = CIMTYPE_OBJECT;

else

type = CIMTYPE_INSTANCE;

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

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

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

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

}

#else

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

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

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

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

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

Line 2654

property.setValue(value);

}

expectEndTag(parser, "PROPERTY.ARRAY");

}

Line 2258

Line 2684

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 2282

Line 2708

}

host = String(entry.text,STRING_FLAG_UTF8);

host = String(entry.text);

#endif

expectEndTag(parser, "HOST");

return true;

Line 2540

Line 2966

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 3558

Line 3984

{

XmlEntry entry;

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

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

return false;

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

Line 3567

Line 3993

cimClass = CIMClass(name, superClass);

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

{

// Get QUALIFIER elements:

getQualifierElements(parser, cimClass);

Line 3585

Line 4014

// Get CLASS end tag:

expectEndTag(parser, "CLASS");

}

return true;

}

Line 3852

Line 4282

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 3886

Line 4319

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 3913

Line 4349

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

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

Line 4426

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

// getErrorElement()

// DMTF CR Pending

// <!ELEMENT ERROR EMPTY>

// <!ELEMENT ERROR (INSTANCE*)>

// <!ATTLIST ERROR

// CODE CDATA #REQUIRED

// DESCRIPTION CDATA #IMPLIED>

Line 4031

Line 4487

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 4061

Line 4524

{

object = CIMObject(cimInstance);

}

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

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

{

object = CIMObject(cimClass);

}

Line 4324

Line 4787

}

return false;

PEGASUS_UNREACHABLE( return false; )

}

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

Line 4411

Line 4874

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 4515

Line 4981

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 4548

Line 5017

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

// <!ATTLIST PARAMVALUE

// %CIMName;

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

Line 4558

Line 5028

{

XmlEntry entry;

const char* name;

CIMType type;

CIMType type=CIMTYPE_BOOLEAN;

CIMValue value;

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

Line 4581

Line 5051

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 4621

Line 5099

effectiveType = type;

}

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

// then

// Convert the EmbeddedObject-encoded string into a CIMObject

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

Boolean isEmbeddedObject = String::equal(embeddedObject, "object");

Boolean isEmbeddedInstance = String::equal(embeddedObject, "instance");

if(isEmbeddedObject || isEmbeddedInstance)

{

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

// The type must have been specified.

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

{

if(isEmbeddedObject)

effectiveType = CIMTYPE_OBJECT; // Used below by getValueElement() or getValueArrayElement()

else

effectiveType = CIMTYPE_INSTANCE;

}

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

}

#else

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

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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 4642

Line 5184

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

// <!ATTLIST RETURNVALUE

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

Line 4657

Line 5200

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 4696

Line 5244

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

type = CIMTYPE_STRING;

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

Boolean isEmbeddedObject = String::equal(embeddedObject, "object");

Boolean isEmbeddedInstance = String::equal(embeddedObject, "instance");

if(isEmbeddedObject || isEmbeddedInstance)

{

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

{

if(isEmbeddedObject)

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

else

type = CIMTYPE_INSTANCE;

}

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

}

#else

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

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

{

Line 4718

Line 5317

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.92
changed lines
	Added in v.1.115.2.2

No CVS admin address has been configured