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.6 and 1.29

version 1.6, 2001/04/08 01:13:22

version 1.29, 2002/02/22 02:48:01

Line 1

//BEGIN_LICENSE

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

// The Open Group, Tivoli Systems

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

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

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

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

// to deal in the Software without restriction, including without limitation

// deal in the Software without restriction, including without limitation the

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// and/or sell copies of the Software, and to permit persons to whom the

// sell copies of the Software, and to permit persons to whom the Software is

// Software is furnished to do so, subject to the following conditions:

// furnished to do so, subject to the following conditions:

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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

// Author: Mike Brasher (mbrasher@bmc.com)

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

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

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

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

// DEALINGS IN THE SOFTWARE.

//END_LICENSE

//BEGIN_HISTORY

// Author:

// $Log$

// Revision 1.6 2001/04/08 01:13:22 mike

// Changed "ConstCIM" to "CIMConst"

// Revision 1.4 2001/02/26 04:33:28 mike

// Fixed many places where cim names were be compared with operator==(String,String).

// Changed all of these to use CIMName::equal()

// Revision 1.3 2001/02/19 01:47:16 mike

// Renamed names of the form CIMConst to CIMConst.

// Revision 1.2 2001/02/16 02:06:07 mike

// Renamed many classes and headers.

// Revision 1.1.1.1 2001/01/14 19:53:32 mike

// Pegasus import

//END_HISTORY

#include <cassert>

#include <cctype>

Line 53

Line 41

#include "CIMQualifierDecl.h"

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

Line 71

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

// testXmlDeclaration ()

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

Boolean XmlReader::testXmlDeclaration (

XmlParser& parser,

XmlEntry& entry)

{

if (!parser.next (entry) ||

entry.type != XmlEntry::XML_DECLARATION ||

strcmp (entry.text, "xml") != 0)

{

parser.putBack (entry);

return false;

}

return true;

}

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

// expectStartTag()

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

Line 113

Line 126

strcmp(entry.text, tagName) != 0)

{

char message[MESSAGE_SIZE];

sprintf(message, "Expected close of %s element", tagName);

sprintf(message, "Expected close of %s element, got %s instead",

tagName,entry.text);

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

}

Line 288

Line 302

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

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

}

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

// getCimNameAttribute()

// <!ENTITY % CIMName "NAME CDATA #REQUIRED">

Line 343

Line 323

throw XmlValidationError(lineNumber, buffer);

}

if (acceptNull && name.getLength() == 0)

if (acceptNull && name.size() == 0)

return name;

if (!CIMName::legal(name))

Line 480

Line 460

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

Line 530

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 788

Line 786

{

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

if (strlen(valueString)==0)

{

switch (type)

{

case CIMType::BOOLEAN: return CIMValue(false);

case CIMType::STRING: return CIMValue(valueString);

case CIMType::CHAR16: return CIMValue(Char16('\0'));

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

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

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

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

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

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

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

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

case CIMType::REAL32: return CIMValue(Real32(0));

case CIMType::REAL64: return CIMValue(Real64(0));

}

switch (type)

{

case CIMType::BOOLEAN:

{

if (strcmp(valueString, "TRUE") == 0)

if (CompareNoCase(valueString, "TRUE") == 0)

return CIMValue(true);

else if (strcmp(valueString, "FALSE") == 0)

else if (CompareNoCase(valueString, "FALSE") == 0)

return CIMValue(false);

else

throw XmlSemanticError(

Line 920

Line 938

// Get VALUE start tag:

XmlEntry entry;

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

return false;

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

// Get VALUE content:

const char* valueString = "";

if (!empty)

Line 939

Line 954

}

value = stringToValue(parser.getLine(), valueString,type);

return true;

}

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

// getStringValueElement()

// <!ELEMENT VALUE (#PCDATA)>

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

Boolean XmlReader::getStringValueElement(

XmlParser& parser,

String& str,

Boolean required)

{

XmlEntry entry;

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

{

if (required)

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

return false;

}

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

const char* valueString = "";

if (!empty)

{

if (testContentOrCData(parser, entry))

valueString = entry.text;

expectEndTag(parser, "VALUE");

}

str = valueString;

return true;

}

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

// getPropertyValue

// Use: Decode property value from getPropertyResponse

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

// PropertyValue:

// <!ELEMENT VALUE>

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

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

// INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>

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

Boolean XmlReader::getPropertyValue(

XmlParser& parser,

CIMValue& cimValue)

{

//ATTN: Test for Element value type

CIMType type = CIMType::STRING;

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

{

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

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

return true;

}

//Test for Element.array value

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

return true;

// Test for Value.reference type

CIMReference reference;

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

{

cimValue.set(reference);

return true;

}

return false;

}

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

// stringArrayToValue()

Line 957

Line 1055

{

Array<T> array;

for (Uint32 i = 0, n = stringArray.getSize(); i < n; i++)

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

{

CIMValue value = XmlReader::stringToValue(

lineNumber, stringArray[i], type);

Line 1546

Line 1644

while (getNameSpaceElement(parser, nameSpaceComponent))

{

if (nameSpace.getLength())

if (nameSpace.size())

nameSpace += '/';

nameSpace += nameSpaceComponent;

}

if (!nameSpace.getLength())

if (!nameSpace.size())

{

throw XmlValidationError(parser.getLine(),

"Expected one or more NAMESPACE elements within "

Line 1644

Line 1742

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

KeyBinding::CIMType XmlReader::getValueTypeAttribute(

KeyBinding::Type XmlReader::getValueTypeAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* elementName)

Line 1680

Line 1778

// <!ATTLIST KEYVALUE

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

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

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

Boolean XmlReader::getKeyValueElement(

XmlParser& parser,

KeyBinding::CIMType& type,

KeyBinding::Type& type,

String& value)

{

XmlEntry entry;

Line 1724

Line 1820

// <!ATTLIST KEYBINDING

// %CIMName;>

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

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

Boolean XmlReader::getKeyBindingElement(

XmlParser& parser,

String& name,

String& value,

KeyBinding::CIMType& type)

KeyBinding::Type& type)

{

XmlEntry entry;

Line 1742

Line 1836

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 1756

Line 1861

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

// ATTN-B: KEYVALUE sub-element nothandled yet.

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

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

Line 1778

Line 1883

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

if (!empty)

if (empty)

{

return true;

}

String name;

KeyBinding::CIMType type;

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;

}

Boolean XmlReader::getInstanceNameElement(

XmlParser& parser,

CIMReference& instanceName)

{

String className;

Array<KeyBinding> keyBindings;

if (!XmlReader::getInstanceNameElement(parser, className, keyBindings))

return false;

instanceName.set(String(), String(), className, keyBindings);

return true;

}

Line 2028

Line 2164

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

// getValueReferenceArrayElement()

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

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

Boolean XmlReader::getValueReferenceArrayElement(

XmlParser& parser,

CIMValue& value)

{

XmlEntry entry;

value.clear();

// Get VALUE.REFARRAY open tag:

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

return false;

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

// ATTN-RK-P3-20020220: Should the type and array size get set in

// the value even though it is null? (See also getValueArrayElement.)

return true;

// For each VALUE.REFERENCE element:

Array<CIMReference> referenceArray;

CIMReference reference;

while (getValueReferenceElement(parser, reference))

{

referenceArray.append(reference);

}

expectEndTag(parser, "VALUE.REFARRAY");

value.set(referenceArray);

return true;

}

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

// getPropertyReferenceElement()

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

Line 2260

Line 2438

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

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

Line 2502

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

XmlReader::getParameterArrayElement(parser, parameter) ||

XmlReader::getParameterReferenceElement(parser, parameter))

XmlReader::getParameterReferenceElement(parser, parameter) ||

XmlReader::getParameterReferenceArrayElement(parser, parameter))

{

try

{

Line 2321

Line 2553

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

Line 2659

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 2521

Line 2755

}

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

// getNamedInstanceElement()

// getMessageStartTag()

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

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

Boolean XmlReader::getMessageStartTag(

Boolean XmlReader::getNamedInstanceElement(

XmlParser& parser,

Uint32& id,

CIMNamedInstance& namedInstance)

const char*& protocolVersion)

{

XmlEntry entry;

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

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

return false;

// Get MESSAGE.ID:

CIMReference instanceName;

if (!entry.getAttributeValue("ID", id))

// Get INSTANCENAME elements:

if (!getInstanceNameElement(parser, instanceName))

{

throw XmlValidationError(parser.getLine(),

"Bad or missing MESSAGE.ID attribute");

"expected INSTANCENAME element");

}

// Get MESSAGE.PROTOCOLVERSION:

CIMInstance instance;

if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion))

// Get INSTANCE elements:

throw XmlValidationError(parser.getLine(),

"Bad or missing MESSAGE.ID attribute");

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

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

void XmlReader::getObject(XmlParser& parser, CIMClass& x)

{

if (!getClassElement(parser, x))

{

throw XmlValidationError(parser.getLine(),

"expected CLASS element");

}

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

// getObject()

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

void XmlReader::getObject(XmlParser& parser, CIMInstance& x)

{

if (!getInstanceElement(parser, x))

{

throw XmlValidationError(parser.getLine(),

"expected INSTANCE element");

}

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

// getObject()

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

void XmlReader::getObject(XmlParser& parser, CIMQualifierDecl& x)

{

if (!getQualifierDeclElement(parser, x))

{

throw XmlValidationError(parser.getLine(),

"expected QUALIFIER.DECLARATION element");

}

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

// getMessageStartTag()

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

Boolean XmlReader::getMessageStartTag(

XmlParser& parser,

String& id,

const char*& protocolVersion)

{

XmlEntry entry;

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

return false;

// Get MESSAGE.ID:

if (!entry.getAttributeValue("ID", id))

throw XmlValidationError(parser.getLine(),

"Bad or missing MESSAGE.ID attribute");

// Get MESSAGE.PROTOCOLVERSION:

if (!entry.getAttributeValue("PROTOCOLVERSION", protocolVersion))

throw XmlValidationError(parser.getLine(),

"Bad or missing MESSAGE.PROTOCOLVERSION attribute");

return true;

}

Line 2650

Line 2974

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 2676

Line 3000

Boolean XmlReader::getErrorElement(

XmlParser& parser,

CIMException::Code& code,

CIMStatusCode& code,

const char*& description,

Boolean required)

{

Line 2699

Line 3023

throw XmlValidationError(

parser.getLine(), "missing ERROR.CODE attribute");

code = CIMException::Code(tmpCode);

code = CIMStatusCode(tmpCode);

// Get ERROR.DESCRIPTION:

Line 2712

Line 3036

return true;

}

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

// getObjectWithPath()

// <!ELEMENT VALUE.OBJECTWITHPATH ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))>

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

Boolean XmlReader::getObjectWithPath(

XmlParser& parser,

CIMObjectWithPath& objectWithPath)

{

XmlEntry entry;

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

return false;

CIMReference reference;

Boolean isInstance = false;

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

isInstance = true;

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

{

throw XmlValidationError(parser.getLine(),

"Expected INSTANCE element");

}

if (isInstance)

{

CIMInstance cimInstance;

if (!XmlReader::getInstanceElement(parser, cimInstance))

{

throw XmlValidationError(parser.getLine(),

"Expected INSTANCEPATH or CLASSPATH element");

}

objectWithPath.set(reference, CIMObject(cimInstance));

}

else

{

CIMClass cimClass;

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

{

throw XmlValidationError(parser.getLine(),

"Expected CLASS element");

}

objectWithPath.set(reference, CIMObject(cimClass));

}

expectEndTag(parser, "VALUE.OBJECTWITHPATH");

return true;

}

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

// <objectName>: (CLASSNAME|INSTANCENAME)

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

Boolean XmlReader::getObjectNameElement(

XmlParser& parser,

CIMReference& objectName)

{

String className;

if (getClassNameElement(parser, className, false))

{

objectName.set(String(), String(), className);

return true;

}

else if (getInstanceNameElement(parser, objectName))

return true;

else

{

throw XmlValidationError(parser.getLine(),

"expected CLASSNAME or INSTANCENAME element");

}

return false;

}

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

// <!ELEMENT OBJECTPATH (INSTANCEPATH|CLASSPATH)>

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

Boolean XmlReader::getObjectPathElement(

XmlParser& parser,

CIMReference& objectPath)

{

XmlEntry entry;

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

return false;

if (getClassPathElement(parser, objectPath))

{

expectEndTag(parser, "OBJECTPATH");

return true;

}

else if (getInstancePathElement(parser, objectPath))

{

expectEndTag(parser, "OBJECTPATH");

return true;

}

else

{

throw XmlValidationError(parser.getLine(),

"expected INSTANCEPATH or CLASSPATH element");

}

PEGASUS_UNREACHABLE ( return false; )

}

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

// getEMethodCallStartTag()

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

Boolean XmlReader::getEMethodCallStartTag(

XmlParser& parser,

const char*& name)

{

XmlEntry entry;

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

return false;

// Get EXPMETHODCALL.NAME attribute:

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

throw XmlValidationError(parser.getLine(),

"Missing EXPMETHODCALL.NAME attribute");

return true;

}

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

// getEMethodResponseStartTag()

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

Boolean XmlReader::getEMethodResponseStartTag(

XmlParser& parser,

const char*& name)

{

XmlEntry entry;

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

return false;

// Get EXPMETHODRESPONSE.NAME attribute:

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

throw XmlValidationError(parser.getLine(),

"Missing EXPMETHODRESPONSE.NAME attribute");

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

}

// ATTN-RK-P2-20020221: Any other properties to set in CIMParameter?

// (referenceClassName)

paramValue = CIMParamValue(CIMParameter(name, type, value.isArray(), value.getArraySize()), value);

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.6
changed lines
	Added in v.1.29

No CVS admin address has been configured