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.26 and 1.34

version 1.26, 2002/02/20 03:51:29

version 1.34, 2002/03/06 05:12:05

Line 265

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

// testCimStartTag()

// getCimStartTag()

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

// <!ATTRLIST CIM

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

}

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

Line 788

Line 779

if (strlen(valueString)==0)

{

// This needs to reflect the Null result. KSTESTNULL

// ATTN: review the other code for this characteristic

// In all cases, XML with an empty entry is NULL <VALUE></VALUE>

return CIMValue(type, false);

/* KS 27 Feb 2002 Droped this code in favor of inserting the Null version

switch (type)

{

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

Line 804

Line 800

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

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

}

switch (type)

Line 999

Line 996

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

// getPropertyValue

// Use: Decode property value from getPropertyResponse

// Use: Decode property value from SetProperty request and

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

// GetProperty response.

// PropertyValue:

// PropertyValue is one of:

// <!ELEMENT VALUE>

// <!ELEMENT VALUE.ARRAY (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)

{

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

CIMReference reference;

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

{

Line 1037

Line 1040

return true;

}

// Test for VALUE.REFARRAY element

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

{

return true;

}

return false;

}

Line 1143

Line 1152

// Get VALUE.ARRAY open tag:

XmlEntry entry;

Array<const char*> stringArray;

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

return false;

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

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

return true;

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

Line 1182

}

expectEndTag(parser, "VALUE.ARRAY");

}

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

return true;

Line 2164

Line 2176

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

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

Line 2862

Boolean XmlReader::getMessageStartTag(

XmlParser& parser,

String& id,

const char*& protocolVersion)

String& protocolVersion)

{

XmlEntry entry;

Line 3255

Line 3306

value.set(reference);

type = CIMType::REFERENCE;

}

// ATTN-RK-P2-20010219: This method does not exist. CIMValue does

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

// not currently allow for an array of CIMReferences.

{

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

type = CIMType::REFERENCE;

//{

}

// type = CIMType::REFERENCE;

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

//}

}

// Parse non-reference value

Line 3283

Line 3333

expectEndTag(parser, "PARAMVALUE");

}

paramValue = CIMParamValue(CIMParameter(name, type), value);

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;

}

Legend:

Removed from v.1.26
changed lines
	Added in v.1.34

No CVS admin address has been configured