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.16 and 1.24.2.7

version 1.16, 2001/06/16 17:30:38

version 1.24.2.7, 2001/11/08 23:15:30

Line 1

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

// The Open Group, Tivoli Systems

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

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

Line 22

Line 23

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

// Modified By:

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

// (carolann_graves@hp.com)

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

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

Line 37

Line 41

#include "CIMQualifierDecl.h"

#include "CIMClass.h"

#include "CIMInstance.h"

#include "CIMObject.h"

#include "CIMParamValue.h"

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

static const Uint32 MESSAGE_SIZE = 128;

Line 63

Line 70

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

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

Line 301

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

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

Line 508

type = CIMType::REAL32;

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

type = CIMType::REAL64;

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

type = CIMType::REFERENCE;

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

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

if (type == CIMType::NONE)

{

Line 773

Line 762

{

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

//SNIA

if (strlen(valueString)==0)

if (strlen(valueString)==0) {

{

switch (type) {

switch (type)

{

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

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

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

Line 791

Line 781

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

}

// end of SNIA

switch (type)

{

Line 930

Line 919

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

// Get VALUE content:

const char* valueString = "";

// cout << "DEBUG XMLReader:getValueElement " << __LINE__ ;

if (!empty)

{

if (testContentOrCData(parser, entry))

valueString = entry.text;

//cout << "DEBUG XMLReader:getValueElement " << __LINE__

// << " valueString " << valueString ;

expectEndTag(parser, "VALUE");

}

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

//cout << "DEBUG XMLReader:getValueElement " << __LINE__

// << " value " << value;

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;

}

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

Line 971

Line 991

XmlParser& parser,

CIMValue& cimValue)

{

//Test for Element value type

//ATTN: Test for Element value type

CIMType type = CIMType::STRING;

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

Line 986

Line 1006

return true;

// Test for Value.reference type

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

// ATTN: Possibly change to simply return result after

// we figure out the type differences.

CIMReference reference;

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

{

cimValue.set(reference);

return true;

}

return false;

}

Line 1735

Line 1754

// <!ATTLIST KEYVALUE

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

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

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

Boolean XmlReader::getKeyValueElement(

Line 1779

Line 1796

// <!ATTLIST KEYBINDING

// %CIMName;>

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

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

Boolean XmlReader::getKeyBindingElement(

Line 1797

Line 1812

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 1811

Line 1837

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

Line 1859

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

if (!empty)

if (empty)

{

return true;

}

String name;

KeyBinding::Type type;

String value;

CIMReference reference;

if (getKeyValueElement(parser, type, value))

{

// Use empty key name because none was specified

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

}

else if (getValueReferenceElement(parser, reference))

{

// Use empty key name because none was specified

type = KeyBinding::REFERENCE;

value = reference.toString();

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

}

else

{

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

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

}

if (!empty)

expectEndTag(parser, "INSTANCENAME");

return true;

}

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 2376

Line 2433

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

Line 2807

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 2763

Line 2820

return true;

}

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

// getErrorElement()

Line 2781

Line 2833

Boolean XmlReader::getErrorElement(

XmlParser& parser,

CIMException::Code& code,

CIMStatusCode& code,

const char*& description,

Boolean required)

{

Line 2804

Line 2856

throw XmlValidationError(

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

code = CIMException::Code(tmpCode);

code = CIMStatusCode(tmpCode);

// Get ERROR.DESCRIPTION:

Line 2817

Line 2869

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;

CIMReference instanceName;

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;

}

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

// getParamValueTag()

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

Boolean XmlReader::getParamValueTag(

XmlParser& parser,

const char*& name)

{

XmlEntry entry;

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

return false;

// Get IPARAMVALUE.NAME attribute:

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

throw XmlValidationError(parser.getLine(),

"Missing PARAMVALUE.NAME attribute");

return true;

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.16
changed lines
	Added in v.1.24.2.7

No CVS admin address has been configured