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.150

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

version 1.150, 2014/08/27 23:10:08

Line 1

//BEGIN_LICENSE

//%LICENSE////////////////////////////////////////////////////////////////

// Licensed to The Open Group (TOG) under one or more contributor license

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

// this work for additional information regarding copyright ownership.

// Each contributor licenses this file to you under the OpenPegasus Open

// Source License; you may not use this file except in compliance with the

// License.

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

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

Line 9

Line 14

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

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

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

// The above copyright notice and this permission notice shall be included

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

// in all copies or substantial portions of the Software.

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

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

//BEGIN_HISTORY

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

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

// Author:

// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

// $Log$

// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

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

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

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

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/Constants.h>

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

#include <errno.h>

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

#include <cstdio>

#include <cstdlib>

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

# include <errno.h>

#endif

#include "CIMName.h"

#include "CIMNameCast.h"

#include "XmlReader.h"

#include "XmlWriter.h"

#include "CIMQualifier.h"

#include "CIMQualifierDecl.h"

#include "CIMClass.h"

#include "CIMInstance.h"

#include "CIMObject.h"

#include "CIMParamValue.h"

#include "System.h"

#include "XmlConstants.h"

#include <Pegasus/Common/MessageLoader.h>

#include <Pegasus/Common/StringConversion.h>

#include <Pegasus/Common/AutoPtr.h>

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

static const Uint32 MESSAGE_SIZE = 128;

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

// expectXmlDeclaration()

// getXmlDeclaration()

// <?xml version="1.0" encoding="utf-8"?>

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

void XmlReader::expectXmlDeclaration(

void XmlReader::getXmlDeclaration(

XmlParser& parser,

XmlEntry& entry)

const char*& xmlVersion,

const char*& xmlEncoding)

{

XmlEntry entry;

if (!parser.next(entry) ||

entry.type != XmlEntry::XML_DECLARATION ||

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

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_XML_STYLE",

"Expected <?xml ... ?> style declaration");

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

}

if (!entry.getAttributeValue("version", xmlVersion))

{

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_XML_ATTRIBUTE",

"missing xml.version attribute");

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

}

if (!entry.getAttributeValue("encoding", xmlEncoding))

{

// ATTN-RK-P3-20020403: Is there a default encoding?

}

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

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

}

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

Line 92

Line 134

entry.type != XmlEntry::START_TAG ||

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

{

char message[MESSAGE_SIZE];

MessageLoaderParms mlParms(

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

"Common.XmlReader.EXPECTED_OPEN",

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

"Expected open of $0 element",

tagName);

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

}

Line 112

Line 156

entry.type != XmlEntry::END_TAG ||

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

{

char message[MESSAGE_SIZE];

MessageLoaderParms mlParms(

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

"Common.XmlReader.EXPECTED_CLOSE",

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

"Expected close of $0 element, got $1 instead",

tagName,entry.text);

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

}

Line 134

Line 180

entry.type != XmlEntry::EMPTY_TAG) ||

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

{

char message[MESSAGE_SIZE];

MessageLoaderParms mlParms(

sprintf(message,

"Common.XmlReader.EXPECTED_OPENCLOSE",

"Expected either open or open/close %s element", tagName);

"Expected either open or open/close $0 element",

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

tagName);

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

}

Line 155

Line 202

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

entry.type != XmlEntry::CDATA))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"Expected content of CDATA");

"Common.XmlReader.EXPECTED_CDATA",

"Expected content or CDATA");

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

}

return true;

Line 186

Line 235

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

// testEndTag>()

// testEndTag()

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

Line 216

Line 265

XmlEntry& entry,

const char* tagName)

{

if (!parser.next(entry) ||

if (!parser.next(entry))

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

{

return false;

}

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

entry.type != XmlEntry::EMPTY_TAG) ||

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

{

Line 230

Line 282

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

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

Line 324

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

// testCimStartTag()

// getCimStartTag()

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

// <!ATTRLIST CIM

Line 260

Line 333

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

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

}

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

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

MessageLoaderParms mlParms(

return true;

"Common.XmlReader.MISSING_CIMVERSION_ATTRIBUTE",

"missing CIM.CIMVERSION attribute");

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

}

else if (strcmp(tmp, "false") == 0)

if (!entry.getAttributeValue("DTDVERSION", dtdVersion))

{

value = false;

MessageLoaderParms mlParms(

return true;

"Common.XmlReader.MISSING_DTDVERSION_ATTRIBUTE",

"missing CIM.DTDVERSION attribute");

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

}

char buffer[62];

sprintf(buffer, "Bad %s.%s attribute value", "ISARRAY", tagName);

throw XmlSemanticError(lineNumber, buffer);

return false;

}

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

Line 328

Line 366

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

String XmlReader::getCimNameAttribute(

CIMName XmlReader::getCimNameAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* elementName,

Boolean acceptNull)

{

String name;

const char* name;

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

{

char buffer[MESSAGE_SIZE];

sprintf(buffer, "missing %s.NAME attribute", elementName);

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

throw XmlValidationError(lineNumber, buffer);

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_ATTRIBUTE",

"missing $0 attribute",

buffer);

throw XmlValidationError(lineNumber, mlParms);

}

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

if (acceptNull && *name == '\0')

return name;

return CIMName();

Uint32 size = CIMNameLegalASCII(name);

if (size)

{

String tmp(name, size);

return CIMName(CIMNameCast(tmp));

}

if (!CIMName::legal(name))

{

char buffer[MESSAGE_SIZE];

sprintf(buffer, "Illegal value for %s.NAME attribute", elementName);

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

throw XmlSemanticError(lineNumber, buffer);

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

return name;

return CIMNameCast(name);

}

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

Line 374

Line 431

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

{

char buffer[MESSAGE_SIZE];

sprintf(buffer, "missing %s.CLASSNAME attribute", elementName);

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

throw XmlValidationError(lineNumber, buffer);

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_ATTRIBUTE",

"missing $0 attribute",

buffer);

throw XmlValidationError(lineNumber, mlParms);

}

if (!CIMName::legal(name))

{

char buffer[MESSAGE_SIZE];

sprintf(buffer,

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

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

throw XmlSemanticError(lineNumber, buffer);

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

return name;

Line 397

Line 464

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

String XmlReader::getClassOriginAttribute(

CIMName XmlReader::getClassOriginAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* tagName)

Line 405

Line 472

String name;

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

return String();

return CIMName();

/* Interoperability hack to make the C++ client of OpenPegasus able

to deal with the wbemservices CIMOM delivered with Sun Solaris.

The issue is that the wbemservices delivers Xml responses with

CLASSORIGIN=""

Originally this had been reported with Bug#537.

if (name.size()==0)

{

return CIMName();

}

if (!CIMName::legal(name))

{

char buffer[MESSAGE_SIZE];

sprintf(buffer,

sprintf(buffer, "%s.CLASSORIGIN", tagName);

"Illegal value for %s.CLASSORIGIN attribute", tagName);

throw XmlSemanticError(lineNumber, buffer);

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

// The CIMName was already checked with legal() + String()

return CIMNameCast(name);

}

return name;

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

// getEmbeddedObjectAttribute()

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

// EmbeddedObjectAttributeType:

// NO_EMBEDDED_OBJECT = 0,

// EMBEDDED_OBJECT_ATTR = 1,

// EMBEDDED_INSTANCE_ATTR = 2

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

XmlReader::EmbeddedObjectAttributeType XmlReader::getEmbeddedObjectAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* tagName)

{

const char* embeddedObject;

// Check for both upper case and mixed case "EmbeddedObject"

// because of an error in an earlier pegasus version where we

// used upper case in the generation of the attribute name

// whereas the DMTF spec calls for mixed case.

if (!entry.getAttributeValue("EmbeddedObject", embeddedObject) &&

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

return NO_EMBEDDED_OBJECT;

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

// value "object" or "instance".

if (strcmp(embeddedObject, "object") == 0)

{

return EMBEDDED_OBJECT_ATTR;

}

if (strcmp(embeddedObject, "instance") == 0)

{

return EMBEDDED_INSTANCE_ATTR;

}

char buffer[MESSAGE_SIZE];

sprintf(buffer, "%s.EmbeddedObject", tagName);

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

return NO_EMBEDDED_OBJECT;

}

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

Line 426

Line 560

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

String XmlReader::getReferenceClassAttribute(

CIMName XmlReader::getReferenceClassAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* elementName)

Line 434

Line 568

String name;

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

return String();

return CIMName();

if (!CIMName::legal(name))

{

char buffer[MESSAGE_SIZE];

sprintf(buffer,

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

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

throw XmlSemanticError(lineNumber, buffer);

}

return name;

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

// The CIMName was already checked with legal() + String()

return CIMNameCast(name);

}

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

Line 455

Line 593

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

String XmlReader::getSuperClassAttribute(

CIMName XmlReader::getSuperClassAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* tagName)

Line 463

Line 601

String superClass;

if (!entry.getAttributeValue("SUPERCLASS", superClass))

return String();

return CIMName();

if (!CIMName::legal(superClass))

{

char buffer[MESSAGE_SIZE];

sprintf(

sprintf(buffer, "%s.SUPERCLASS", tagName);

buffer, "Illegal value for %s.SUPERCLASS attribute", tagName);

throw XmlSemanticError(lineNumber, buffer);

}

return superClass;

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

// The CIMName was already checked with legal() + String()

return CIMNameCast(superClass);

}

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

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

Boolean XmlReader::getCimTypeAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* tagName)

CIMType& cimType, // Output parameter

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, "%s.%s", tagName, attributeName);

throw XmlValidationError(lineNumber, message);

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_ATTRIBUTE",

"missing $0 attribute",

message);

throw XmlValidationError(lineNumber, mlParms);

}

else

{

return false;

}

CIMType type = CIMType::NONE;

CIMType type = CIMTYPE_BOOLEAN;

Boolean unrecognizedType = false;

if (strcmp(typeName, "boolean") == 0)

type = CIMType::BOOLEAN;

type = CIMTYPE_BOOLEAN;

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

type = CIMType::STRING;

type = CIMTYPE_STRING;

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

type = CIMType::CHAR16;

type = CIMTYPE_CHAR16;

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

type = CIMType::UINT8;

type = CIMTYPE_UINT8;

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

type = CIMType::SINT8;

type = CIMTYPE_SINT8;

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

type = CIMType::UINT16;

type = CIMTYPE_UINT16;

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

type = CIMType::SINT16;

type = CIMTYPE_SINT16;

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

type = CIMType::UINT32;

type = CIMTYPE_UINT32;

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

type = CIMType::SINT32;

type = CIMTYPE_SINT32;

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

type = CIMType::UINT64;

type = CIMTYPE_UINT64;

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

type = CIMType::SINT64;

type = CIMTYPE_SINT64;

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

type = CIMType::DATETIME;

type = CIMTYPE_DATETIME;

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

type = CIMType::REAL32;

type = CIMTYPE_REAL32;

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

type = CIMType::REAL64;

type = CIMTYPE_REAL64;

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

type = CIMType::REFERENCE;

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

((type == CIMTYPE_REFERENCE) &&

(strcmp(attributeName, "PARAMTYPE") != 0)))

{

char buffer[MESSAGE_SIZE];

sprintf(buffer, "%s.%s", tagName, attributeName);

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

MessageLoaderParms mlParms(

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

"Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

if (type == CIMType::NONE)

throw XmlSemanticError(lineNumber, mlParms);

{

char message[MESSAGE_SIZE];

sprintf(message, "Illegal value for %s.TYPE attribute", tagName);

throw XmlSemanticError(lineNumber, message);

}

return type;

cimType = type;

return true;

}

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

Line 566

Line 744

if (!required)

return defaultValue;

char buffer[62];

char buffer[MESSAGE_SIZE];

sprintf(buffer, "missing required %s.%s attribute",

sprintf(buffer, "%s.%s", attributeName, tagName);

attributeName, tagName);

throw XmlValidationError(lineNumber, buffer);

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_REQUIRED_ATTRIBUTE",

"missing required $0 attribute",

buffer);

throw XmlValidationError(lineNumber, mlParms);

}

if (strcmp(tmp, "true") == 0)

Line 578

Line 759

else if (strcmp(tmp, "false") == 0)

return false;

char buffer[62];

char buffer[MESSAGE_SIZE];

sprintf(buffer, "Bad %s.%s attribute value", attributeName, tagName);

sprintf(buffer, "%s.%s", attributeName, tagName);

throw XmlSemanticError(lineNumber, buffer);

return false;

}

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

// SringToReal()

// [ "+" | "-" ] *decimalDigit "." 1*decimalDigit

// [ ( "e" | "E" ) [ "+" | "-" ] 1*decimalDigit ]

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

Boolean XmlReader::stringToReal(const char* stringValue, Real64& x)

{

const char* p = stringValue;

if (!*p)

return false;

// Skip optional sign:

if (*p == '+' || *p == '-')

p++;

// Skip optional first set of digits:

while (isdigit(*p))

p++;

// Test required dot:

if (*p++ != '.')

MessageLoaderParms mlParms(

return false;

"Common.XmlReader.INVALID_ATTRIBUTE",

"Invalid $0 attribute value",

buffer);

// One or more digits required:

throw XmlSemanticError(lineNumber, mlParms);

if (!isdigit(*p++))

return false;

}

while (isdigit(*p))

// See http://www.ietf.org/rfc/rfc2396.txt section 2

p++;

// Also see the "CIM Operations over HTTP" spec, section 3.3.2 and

// If there is an exponent now:

// 3.3.3, for the treatment of non US-ASCII chars (UTF-8)

String XmlReader::decodeURICharacters(String uriString)

if (*p)

{

// Test exponent:

Uint32 i;

if (*p != 'e' && *p != 'E')

return false;

p++;

// Skip optional sign:

Buffer utf8Chars;

if (*p == '+' || *p == '-')

for (i=0; i<uriString.size(); i++)

p++;

{

if (uriString[i] == '%')

// One or more digits required:

{

if (i+2 >= uriString.size())

if (!isdigit(*p++))

{

return false;

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_URI_ENCODING",

"Invalid URI encoding");

throw ParseError(MessageLoader::getMessage(mlParms));

}

while (isdigit(*p))

Uint8 digit1 =

p++;

StringConversion::hexCharToNumeric(char(uriString[++i]));

Uint8 digit2 =

StringConversion::hexCharToNumeric(char(uriString[++i]));

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

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_URI_ENCODING",

"Invalid URI encoding");

throw ParseError(MessageLoader::getMessage(mlParms));

}

if (*p)

Uint16 decodedChar = Uint16(digit1<<4) + Uint16(digit2);

return false;

utf8Chars.append((char)decodedChar);

}

else

{

utf8Chars.append((char)uriString[i]);

}

char* end;

// If there was a string to decode...

x = strtod(stringValue, &end);

if (uriString.size() > 0)

return true;

{

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

return String(utf8Chars.getData(), utf8Chars.size());

}

else

{

return String();

}

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

// stringToSignedInteger

// stringToValue()

// Return: CIMValue. If the string input is zero length creates a CIMValue

// with value defined by the type. Else the value is inserted.

// [ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" )

// Note that this does not set the CIMValue Null if the string is empty.

// ATTN-B: handle conversion from hexadecimal.

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

Boolean XmlReader::stringToSignedInteger(

CIMValue XmlReader::stringToValue(

const char* stringValue,

Uint32 lineNumber,

Sint64& x)

const char* valueString,

CIMType type)

{

x = 0;

return stringToValue(lineNumber, valueString, strlen(valueString), type);

const char* p = stringValue;

}

if (!*p)

return false;

// Skip optional sign:

Boolean negative = *p == '-';

if (negative || *p == '+')

p++;

// If the next thing is a zero, then it must be the last:

if (*p == '0')

return p[1] == '\0';

// Expect a positive decimal digit:

const char* first = p;

if (!isdigit(*p) || *p == '0')

CIMValue XmlReader::stringToValue(

return false;

Uint32 lineNumber,

const char* valueString,

Uint32 valueStringLen,

CIMType type)

{

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

p++;

// Char string must have been null terminated.

PEGASUS_ASSERT (!valueString[valueStringLen]);

// Expect zero or more digits:

// Create value per type

switch (type)

{

case CIMTYPE_BOOLEAN:

{

if (System::strcasecmp(valueString, "TRUE") == 0)

return CIMValue(true);

else if (System::strcasecmp(valueString, "FALSE") == 0)

return CIMValue(false);

else

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_BOOLEAN_VALUE",

"Invalid boolean value");

throw XmlSemanticError(lineNumber, mlParms);

}

while (isdigit(*p))

case CIMTYPE_STRING:

p++;

{

return CIMValue(String(valueString, valueStringLen));

}

if (*p)

case CIMTYPE_CHAR16:

return false;

{

// Converts UTF-8 to UTF-16

String tmp(valueString, valueStringLen);

if (tmp.size() != 1)

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_CHAR16_VALUE",

"Invalid char16 value");

throw XmlSemanticError(lineNumber, mlParms);

}

const char* last = p;

return CIMValue(tmp[0]);

}

while (first != last)

case CIMTYPE_UINT8:

x = 10 * x + (*first++ - '0');

case CIMTYPE_UINT16:

case CIMTYPE_UINT32:

case CIMTYPE_UINT64:

{

Uint64 x;

if (negative)

if (!StringConversion::stringToUnsignedInteger(valueString, x))

x = -x;

{

MessageLoaderParms mlParms(

return true;

"Common.XmlReader.INVALID_UI_VALUE",

}

"Invalid unsigned integer value");

throw XmlSemanticError(lineNumber, mlParms);

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

}

// stringToUnsignedInteger

// [ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" )

// ATTN-B: handle conversion from hexadecimal.

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

Boolean XmlReader::stringToUnsignedInteger(

const char* stringValue,

Uint64& x)

{

x = 0;

const char* p = stringValue;

if (!*p)

return false;

// Skip optional sign:

if (*p == '-')

return false;

if (*p == '+')

p++;

// If the next thing is a zero, then it must be the last:

if (*p == '0')

return p[1] == '\0';

// Expect a positive decimal digit:

const char* first = p;

if (!isdigit(*p) || *p == '0')

return false;

p++;

// Expect zero or more digits:

while (isdigit(*p))

p++;

if (*p)

return false;

const char* last = p;

while (first != last)

x = 10 * x + (*first++ - '0');

return true;

}

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

// stringToValue()

// ATTN-C: note that integers are truncated without warning. What should be

// done in this case? In C they are truncated without warning by design.

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

CIMValue XmlReader::stringToValue(

Uint32 lineNumber,

const char* valueString,

CIMType type)

{

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

switch (type)

{

case CIMType::BOOLEAN:

case CIMTYPE_UINT8:

{

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

if (!StringConversion::checkUintBounds(x, type))

return CIMValue(true);

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

return CIMValue(false);

else

throw XmlSemanticError(

lineNumber, "Bad boolean value");

}

case CIMType::STRING:

{

return CIMValue(valueString);

MessageLoaderParms mlParms(

"Common.XmlReader.U8_VALUE_OUT_OF_RANGE",

"Uint8 value out of range");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Uint8(x));

case CIMType::CHAR16:

{

if (strlen(valueString) != 1)

throw XmlSemanticError(lineNumber, "Bad char16 value");

return CIMValue(Char16(valueString[0]));

}

case CIMTYPE_UINT16:

case CIMType::UINT8:

case CIMType::UINT16:

case CIMType::UINT32:

case CIMType::UINT64:

{

Uint64 x;

if (!StringConversion::checkUintBounds(x, type))

if (!stringToUnsignedInteger(valueString, x))

{

throw XmlSemanticError(

MessageLoaderParms mlParms(

lineNumber, "Bad unsigned integer value");

"Common.XmlReader.U16_VALUE_OUT_OF_RANGE",

"Uint16 value out of range");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Uint16(x));

switch (type)

}

case CIMTYPE_UINT32:

{

if (!StringConversion::checkUintBounds(x, type))

{

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

MessageLoaderParms mlParms(

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

"Common.XmlReader.U32_VALUE_OUT_OF_RANGE",

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

"Uint32 value out of range");

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

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Uint32(x));

}

case CIMTYPE_UINT64: return CIMValue(Uint64(x));

default: break;

}

case CIMType::SINT8:

case CIMTYPE_SINT8:

case CIMType::SINT16:

case CIMTYPE_SINT16:

case CIMType::SINT32:

case CIMTYPE_SINT32:

case CIMType::SINT64:

case CIMTYPE_SINT64:

{

Sint64 x;

if (!stringToSignedInteger(valueString, x))

if (!StringConversion::stringToSignedInteger(valueString, x))

{

throw XmlSemanticError(

MessageLoaderParms mlParms(

lineNumber, "Bad signed integer value");

"Common.XmlReader.INVALID_SI_VALUE",

"Invalid signed integer value");

throw XmlSemanticError(lineNumber, mlParms);

}

switch (type)

{

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

case CIMTYPE_SINT8:

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

{

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

if (!StringConversion::checkSintBounds(x, type))

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

{

MessageLoaderParms mlParms(

"Common.XmlReader.S8_VALUE_OUT_OF_RANGE",

"Sint8 value out of range");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Sint8(x));

}

case CIMTYPE_SINT16:

{

if (!StringConversion::checkSintBounds(x, type))

{

MessageLoaderParms mlParms(

"Common.XmlReader.S16_VALUE_OUT_OF_RANGE",

"Sint16 value out of range");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Sint16(x));

}

case CIMTYPE_SINT32:

{

if (!StringConversion::checkSintBounds(x, type))

{

MessageLoaderParms mlParms(

"Common.XmlReader.S32_VALUE_OUT_OF_RANGE",

"Sint32 value out of range");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Sint32(x));

}

case CIMTYPE_SINT64: return CIMValue(Sint64(x));

default: break;

}

case CIMType::DATETIME:

case CIMTYPE_DATETIME:

{

CIMDateTime tmp;

try

{

if (valueStringLen != 0)

{

tmp.set(valueString);

}

catch (BadDateTimeFormat&)

}

catch (InvalidDateTimeFormatException&)

{

throw XmlSemanticError(lineNumber, "Bad datetime value");

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_DATETIME_VALUE",

"Invalid datetime value");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(tmp);

}

case CIMType::REAL32:

case CIMTYPE_REAL32:

{

Real64 x;

if (!stringToReal(valueString, x))

if (!StringConversion::stringToReal64(valueString, x))

throw XmlSemanticError(lineNumber, "Bad real value");

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_RN_VALUE",

"Invalid real number value");

throw XmlSemanticError(lineNumber, mlParms);

}

return CIMValue(Real32(x));

}

case CIMType::REAL64:

case CIMTYPE_REAL64:

{

Real64 x;

if (!stringToReal(valueString, x))

if (!StringConversion::stringToReal64(valueString, x))

throw XmlSemanticError(lineNumber, "Bad real value");

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_RN_VALUE",

"Invalid real number value");

throw XmlSemanticError(lineNumber, mlParms);

}

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:

case CIMTYPE_INSTANCE:

{

CIMObject x;

if (*valueString == '\0')

{

return CIMValue(type, false, 0);

}

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[valueStringLen + 1]);

memcpy(tmp_buffer.get(), valueString, valueStringLen + 1);

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

{

if (type == CIMTYPE_INSTANCE)

return CIMValue(cimInstance);

x = CIMObject(cimInstance);

}

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

{

x = CIMObject(cimClass);

}

else

{

if (type == CIMTYPE_OBJECT)

{

// change "element" to "embedded object"

MessageLoaderParms mlParms(

"Common.XmlReader."

"EXPECTED_INSTANCE_OR_CLASS_ELEMENT",

"Expected INSTANCE or CLASS element");

throw XmlValidationError(lineNumber, mlParms);

}

else

{

// change "element" to "embedded object"

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"Expected INSTANCE element");

throw XmlValidationError(lineNumber, mlParms);

}

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

// XmlParser.

tmp_buffer.reset();

}

return CIMValue(x);

}

Line 900

Line 1128

break;

}

throw XmlSemanticError(lineNumber, "malformed XML");

MessageLoaderParms mlParms(

"Common.XmlReader.MALFORMED_XML",

"malformed XML");

throw XmlSemanticError(lineNumber, mlParms);

return false;

}

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

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

// Return: false if no value element.

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

Boolean XmlReader::getValueElement(

Line 917

Line 1181

CIMType type,

CIMValue& value)

{

// Get VALUE start tag:

// Get VALUE start tag: Return false if no 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 = "";

Uint32 valueStringLen = 0;

if (!empty)

{

if (testContentOrCData(parser, entry))

{

valueString = entry.text;

valueStringLen = entry.textLen;

}

expectEndTag(parser, "VALUE");

}

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

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

return true;

}

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

// stringArrayToValue()

// getStringValueElement()

// <!ELEMENT VALUE (#PCDATA)>

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

template<class T>

Boolean XmlReader::getStringValueElement(

CIMValue StringArrayToValueAux(

XmlParser& parser,

Uint32 lineNumber,

String& str,

const Array<const char*>& stringArray,

Boolean required)

CIMType type,

T*)

{

Array<T> array;

XmlEntry entry;

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

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

{

CIMValue value = XmlReader::stringToValue(

if (required)

lineNumber, stringArray[i], type);

{

MessageLoaderParms mlParms(

T x;

"Common.XmlReader.EXPECTED_VALUE_ELEMENT",

value.get(x);

"Expected VALUE element");

array.append(x);

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

}

return false;

return CIMValue(array);

}

CIMValue XmlReader::stringArrayToValue(

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

Uint32 lineNumber,

const Array<const char*>& array,

CIMType type)

{

switch (type)

{

case CIMType::BOOLEAN:

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

case CIMType::STRING:

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

case CIMType::CHAR16:

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

case CIMType::UINT8:

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

case CIMType::UINT16:

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

case CIMType::UINT32:

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

case CIMType::UINT64:

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

case CIMType::SINT8:

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

case CIMType::SINT16:

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

case CIMType::SINT32:

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

case CIMType::SINT64:

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

case CIMType::DATETIME:

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

case CIMType::REAL32:

const char* valueString = "";

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

Uint32 valueStringLen = 0;

case CIMType::REAL64:

if (!empty)

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

{

if (testContentOrCData(parser, entry))

{

valueString = entry.text;

valueStringLen = entry.textLen;

}

default:

expectEndTag(parser, "VALUE");

break;

}

// Unreachable:

str = String(valueString, valueStringLen);

return CIMValue();

return true;

}

// EXP_PULL_BEGIN

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

// getValueArrayElement()

// getUint32ArgValueElement()

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

// <!ELEMENT VALUE (#PCDATA)>

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

Boolean XmlReader::getValueArrayElement(

Boolean XmlReader::getUint32ArgValueElement(

XmlParser& parser,

CIMType type,

Uint32Arg& val,

CIMValue& value)

Boolean required)

{

value.clear();

// Get VALUE.ARRAY open tag:

XmlEntry entry;

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

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

{

if (required)

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_VALUE_ELEMENT",

"Expected VALUE element");

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

}

return false;

}

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

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

return true;

// For each VALUE element:

Array<const char*> stringArray;

const char* valueString = "";

while (testStartTagOrEmptyTag(parser, entry, "VALUE"))

if (!empty)

{

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

if (testContentOrCData(parser, entry))

valueString = entry.text;

expectEndTag(parser, "VALUE");

}

else

{

stringArray.append("");

// create the arg object with the NULL value in it.

continue;

val = Uint32Arg();

return true;

}

if (testContentOrCData(parser, entry))

//convert to Uint32. Note error if overflow.

stringArray.append(entry.text);

else

stringArray.append("");

expectEndTag(parser, "VALUE");

Uint64 x;

if (!StringConversion::stringToUnsignedInteger(valueString, x))

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_UI_VALUE",

"Invalid unsigned integer value");

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

}

expectEndTag(parser, "VALUE.ARRAY");

if (!StringConversion::checkUintBounds(x, CIMTYPE_UINT32))

{

MessageLoaderParms mlParms(

"Common.XmlReader.U32_VALUE_OUT_OF_RANGE",

"Uint32 value out of range");

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

}

// create the arg object with the value in it.

val = Uint32Arg(x);

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

return true;

}

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

// getFlavor()

// getUint64ValueElement()

// <!ENTITY % QualifierFlavor

// <!ELEMENT VALUE (#PCDATA)>

// "OVERRIDABLE (true|false) 'true'

// TOSUBCLASS (true|false) 'true'

// TOINSTANCE (true|false) 'false'

// TRANSLATABLE (true|false) 'false'">

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

Uint32 XmlReader::getFlavor(

Boolean XmlReader::getUint64ValueElement(

XmlEntry& entry,

XmlParser& parser,

Uint64Arg& val,

Boolean required)

{

XmlEntry entry;

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

{

if (required)

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_VALUE_ELEMENT",

"Expected VALUE element");

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

}

return false;

}

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

const char* valueString = "";

if (!empty)

{

if (testContentOrCData(parser, entry))

valueString = entry.text;

expectEndTag(parser, "VALUE");

}

else

{

// create the arg object with the NULL value in it.

val = Uint64Arg();

return true;

}

Uint64 x;

if (!StringConversion::stringToUnsignedInteger(valueString, x))

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_UI_VALUE",

"The unsigned integer value is not valid.");

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

}

// create the arg object with the value in it.

val = Uint64Arg(x);

return true;

}

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

// getUint32ValueElement()

// <!ELEMENT VALUE (#PCDATA)>

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

Boolean XmlReader::getUint32ValueElement(

XmlParser& parser,

Uint32& val,

Boolean required)

{

XmlEntry entry;

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

{

if (required)

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_VALUE_ELEMENT",

"Expected VALUE element");

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

}

return false;

}

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

const char* valueString = "";

if (!empty)

{

if (testContentOrCData(parser, entry))

valueString = entry.text;

expectEndTag(parser, "VALUE");

}

else

{

// leave the existing value

return true;

}

//convert to Uint32. Note error if overflow.

Uint64 x;

if (!StringConversion::stringToUnsignedInteger(valueString, x))

{

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_UI_VALUE",

"Invalid unsigned integer value");

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

}

if (!StringConversion::checkUintBounds(x, CIMTYPE_UINT32))

{

MessageLoaderParms mlParms(

"Common.XmlReader.U32_VALUE_OUT_OF_RANGE",

"Uint32 value out of range");

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

}

// create the arg object with the value in it.

val = x;

return true;

}

//EXP_PULL_END

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

// getPropertyValue

// Use: Decode property value from SetProperty request and

// GetProperty response.

// PropertyValue is one of:

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

{

// Can not test for value type, so assume String

const CIMType type = CIMTYPE_STRING;

// Test for VALUE element

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

{

return true;

}

// Test for VALUE.ARRAY element

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

{

return true;

}

// Test for VALUE.REFERENCE element

CIMObjectPath reference;

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

{

cimValue.set(reference);

return true;

}

// Test for VALUE.REFARRAY element

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

{

return true;

}

return false;

}

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

// stringArrayToValue()

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

template<class T>

CIMValue StringArrayToValueAux(

Uint32 lineNumber,

const Array<CharString>& stringArray,

CIMType type,

T*)

{

Array<T> array;

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

{

CIMValue value = XmlReader::stringToValue(

lineNumber,

stringArray[i].value,

stringArray[i].length,

type);

T x;

value.get(x);

array.append(x);

}

return CIMValue(array);

}

CIMValue XmlReader::stringArrayToValue(

Uint32 lineNumber,

const Array<const char*> &array,

CIMType type)

{

Array<CharString> strArray;

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

{

strArray.append(CharString(array[i], strlen(array[i])));

}

return _stringArrayToValue(lineNumber, strArray, type);

}

CIMValue XmlReader::_stringArrayToValue(

Uint32 lineNumber,

const Array<CharString> &array,

CIMType type)

{

switch (type)

{

case CIMTYPE_BOOLEAN:

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

case CIMTYPE_STRING:

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

case CIMTYPE_CHAR16:

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

case CIMTYPE_UINT8:

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

case CIMTYPE_UINT16:

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

case CIMTYPE_UINT32:

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

case CIMTYPE_UINT64:

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

case CIMTYPE_SINT8:

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

case CIMTYPE_SINT16:

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

case CIMTYPE_SINT32:

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

case CIMTYPE_SINT64:

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

case CIMTYPE_DATETIME:

return StringArrayToValueAux(

lineNumber, array, type, (CIMDateTime*)0);

case CIMTYPE_REAL32:

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

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

case CIMTYPE_INSTANCE:

return StringArrayToValueAux(

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

default:

break;

}

// Unreachable:

return CIMValue();

}

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

// getValueArrayElement()

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

// Return: Boolean. Returns false if there is no VALUE.ARRAY start element

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

Boolean XmlReader::getValueArrayElement(

XmlParser& parser,

CIMType type,

CIMValue& value)

{

// Clears any values from the Array. Assumes this is array CIMValue

value.clear();

// Get VALUE.ARRAY open tag:

XmlEntry entry;

Array<CharString> stringArray;

// If no VALUE.ARRAY start tag, return false

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

return false;

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

{

// For each VALUE element:

while (testStartTagOrEmptyTag(parser, entry, "VALUE"))

{

// ATTN: NULL values in array will have VALUE.NULL subelement

// See DSP0201 Version 2.3.0, Section 5.2.3.2

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

{

stringArray.append(CharString("", 0));

continue;

}

if (testContentOrCData(parser, entry))

{

stringArray.append(CharString(entry.text, entry.textLen));

}

else

{

stringArray.append(CharString("", 0));

}

expectEndTag(parser, "VALUE");

}

expectEndTag(parser, "VALUE.ARRAY");

}

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

return true;

}

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

// getFlavor()

// <!ENTITY % QualifierFlavor

// "OVERRIDABLE (true|false) 'true'

// TOSUBCLASS (true|false) 'true'

// TOINSTANCE (true|false) 'false'

// TRANSLATABLE (true|false) 'false'">

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

CIMFlavor XmlReader::getFlavor(

XmlEntry& entry,

Uint32 lineNumber,

const char* tagName)

{

// Get QUALIFIER.OVERRIDABLE

Boolean overridable = getCimBooleanAttribute(

lineNumber, entry, tagName, "OVERRIDABLE", true, false);

// Get QUALIFIER.TOSUBCLASS

Boolean toSubClass = getCimBooleanAttribute(

lineNumber, entry, tagName, "TOSUBCLASS", true, false);

// Get QUALIFIER.TOINSTANCE

Boolean toInstance = getCimBooleanAttribute(

lineNumber, entry, tagName, "TOINSTANCE", false, false);

// Get QUALIFIER.TRANSLATABLE

Boolean translatable = getCimBooleanAttribute(

lineNumber, entry, tagName, "TRANSLATABLE", false, false);

// Start with CIMFlavor::NONE. Defaults are specified in the

// getCimBooleanAttribute() calls above.

CIMFlavor flavor = CIMFlavor (CIMFlavor::NONE);

if (overridable)

flavor.addFlavor (CIMFlavor::OVERRIDABLE);

else

flavor.addFlavor (CIMFlavor::DISABLEOVERRIDE);

if (toSubClass)

flavor.addFlavor (CIMFlavor::TOSUBCLASS);

else

flavor.addFlavor (CIMFlavor::RESTRICTED);

if (toInstance)

flavor.addFlavor (CIMFlavor::TOINSTANCE);

if (translatable)

flavor.addFlavor (CIMFlavor::TRANSLATABLE);

return flavor;

}

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

// getOptionalScope()

// DTD:

// <!ELEMENT SCOPE EMPTY>

// <!ATTLIST SCOPE

// CLASS (true|false) 'false'

// ASSOCIATION (true|false) 'false'

// REFERENCE (true|false) 'false'

// PROPERTY (true|false) 'false'

// METHOD (true|false) 'false'

// PARAMETER (true|false) 'false'

// INDICATION (true|false) 'false'>

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

CIMScope XmlReader::getOptionalScope(XmlParser& parser)

{

XmlEntry entry;

CIMScope scope;

if (!parser.next(entry))

return scope; // No SCOPE element found; return the empty scope

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

if ((!isEmptyTag &&

entry.type != XmlEntry::START_TAG) ||

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

{

// No SCOPE element found; return the empty scope

parser.putBack(entry);

return scope;

}

Uint32 line = parser.getLine();

if (getCimBooleanAttribute(line, entry, "SCOPE", "CLASS", false, false))

scope.addScope (CIMScope::CLASS);

if (getCimBooleanAttribute(

line, entry, "SCOPE", "ASSOCIATION", false, false))

scope.addScope (CIMScope::ASSOCIATION);

if (getCimBooleanAttribute(

line, entry, "SCOPE", "REFERENCE", false, false))

scope.addScope (CIMScope::REFERENCE);

if (getCimBooleanAttribute(line, entry, "SCOPE", "PROPERTY", false, false))

scope.addScope (CIMScope::PROPERTY);

if (getCimBooleanAttribute(line, entry, "SCOPE", "METHOD", false, false))

scope.addScope (CIMScope::METHOD);

if (getCimBooleanAttribute(line, entry, "SCOPE", "PARAMETER", false, false))

scope.addScope (CIMScope::PARAMETER);

if (getCimBooleanAttribute(line, entry, "SCOPE", "INDICATION",false, false))

scope.addScope (CIMScope::INDICATION);

if (!isEmptyTag)

expectEndTag(parser, "SCOPE");

return scope;

}

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

// getQualifierElement()

// <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)?>

// <!ATTLIST QUALIFIER

// %CIMName;

// %CIMType; #REQUIRED

// %Propagated;

// %QualifierFlavor;>

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

Boolean XmlReader::getQualifierElement(

XmlParser& parser,

CIMQualifier& qualifier)

{

// Get QUALIFIER element:

XmlEntry entry;

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

// Get QUALIFIER.TYPE attribute:

CIMType type;

getCimTypeAttribute(parser.getLine(), entry, type, "QUALIFIER");

// Get QUALIFIER.PROPAGATED

Boolean propagated = getCimBooleanAttribute(

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

// Get flavor oriented attributes:

CIMFlavor flavor = getFlavor(entry, parser.getLine(), "QUALIFIER");

// Get VALUE or VALUE.ARRAY element:

CIMValue value;

if (empty)

{

value.setNullValue(type, false);

}

else

{

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

!getValueArrayElement(parser, type, value))

{

value.setNullValue(type, false);

}

// Expect </QUALIFIER>:

expectEndTag(parser, "QUALIFIER");

}

// Build qualifier:

qualifier = CIMQualifier(name, value, flavor, propagated);

return true;

}

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

// getQualifierElements()

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

template<class CONTAINER>

void getQualifierElements(XmlParser& parser, CONTAINER& container)

{

CIMQualifier qualifier;

while (XmlReader::getQualifierElement(parser, qualifier))

{

try

{

container.addQualifier(qualifier);

}

catch (AlreadyExistsException&)

{

MessageLoaderParms mlParms(

"Common.XmlReader.DUPLICATE_QUALIFIER",

"duplicate qualifier");

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

}

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

// getPropertyElement()

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

// <!ATTLIST PROPERTY

// %CIMName;

// %ClassOrigin;

// %Propagated;

// %EmbeddedObject; #IMPLIED

// %CIMType; #REQUIRED>

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

Boolean XmlReader::getPropertyElement(XmlParser& parser, CIMProperty& property)

{

XmlEntry entry;

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

return false;

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

// Get PROPERTY.NAME attribute:

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

// Get PROPERTY.CLASSORIGIN attribute:

CIMName classOrigin =

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

// Get PROPERTY.PROPAGATED

Boolean propagated = getCimBooleanAttribute(

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

// Get PROPERTY.EmbeddedObject attribute:

EmbeddedObjectAttributeType embeddedObject =

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

// Get PROPERTY.TYPE attribute:

CIMType type;

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

// Create property: Sets type and !isarray

CIMValue value(type, false);

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

if (!empty)

{

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

if (ix != PEG_NOT_FOUND)

{

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

}

String embeddedInstanceQualifierValue;

ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE);

if (ix != PEG_NOT_FOUND)

{

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

embeddedInstanceQualifierValue);

}

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

Boolean isEmbeddedObject = (embeddedObject == EMBEDDED_OBJECT_ATTR) ||

embeddedObjectQualifierValue;

Boolean isEmbeddedInstance = (embeddedObject == EMBEDDED_INSTANCE_ATTR) ||

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 i = 0; i < property.getQualifierCount(); ++i)

{

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

}

value = new_value;

property = new_property;

}

else

{

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

}

return true;

}

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

// getArraySizeAttribute()

// Returns true if able to get array-size. Note that array size will

// always be a positive integer.

// <!ENTITY % ArraySize "ARRAYSIZE CDATA #IMPLIED">

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

Boolean XmlReader::getArraySizeAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* tagName,

Uint32& value)

{

const char* tmp;

if (!entry.getAttributeValue("ARRAYSIZE", tmp))

return false;

Uint64 arraySize;

if (!StringConversion::stringToUnsignedInteger(tmp, arraySize) ||

(arraySize == 0) ||

!StringConversion::checkUintBounds(arraySize, CIMTYPE_UINT32))

{

char message[128];

sprintf(message, "%s.%s", tagName, "ARRAYSIZE");

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE",

"Illegal value for $0",

message);

throw XmlSemanticError(lineNumber, mlParms);

}

value = Uint32(arraySize);

return true;

}

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

// getPropertyArrayElement()

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

// <!ATTLIST PROPERTY.ARRAY

// %CIMName;

// %CIMType; #REQUIRED

// %ArraySize;

// %ClassOrigin;

// %Propagated;

// %EmbeddedObject; #IMPLIED>

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

Boolean XmlReader::getPropertyArrayElement(

XmlParser& parser,

CIMProperty& property)

{

// Get PROPERTY element:

XmlEntry entry;

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

return false;

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

// Get PROPERTY.NAME attribute:

CIMName name =

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

// Get PROPERTY.TYPE attribute:

CIMType type;

getCimTypeAttribute(parser.getLine(), entry, type, "PROPERTY.ARRAY");

// Get PROPERTY.ARRAYSIZE attribute:

Uint32 arraySize = 0;

getArraySizeAttribute(parser.getLine(), entry, "PROPERTY.ARRAY", arraySize);

// Get PROPERTY.CLASSORIGIN attribute:

CIMName classOrigin =

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

// Get PROPERTY.ARRAY.PROPAGATED

Boolean propagated = getCimBooleanAttribute(

parser.getLine(),

entry,

"PROPERTY.ARRAY",

"PROPAGATED",

false,

false);

// Get PROPERTY.EmbeddedObject attribute:

EmbeddedObjectAttributeType embeddedObject = getEmbeddedObjectAttribute(

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

// Create property:

CIMValue value(type, true, arraySize);

property = CIMProperty(

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

if (!empty)

{

// Get qualifiers:

getQualifierElements(parser, property);

}

Boolean embeddedObjectQualifierValue = false;

Uint32 ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT);

if (ix != PEG_NOT_FOUND)

{

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

}

String embeddedInstanceQualifierValue;

ix = property.findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE);

if (ix != PEG_NOT_FOUND)

{

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

embeddedInstanceQualifierValue);

}

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

Boolean isEmbeddedObject = (embeddedObject == EMBEDDED_OBJECT_ATTR) ||

embeddedObjectQualifierValue;

Boolean isEmbeddedInstance = (embeddedObject == EMBEDDED_INSTANCE_ATTR) ||

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 i = 0; i < property.getQualifierCount(); ++i)

{

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

}

value = new_value;

property = new_property;

}

else

{

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

{

MessageLoaderParms mlParms(

"Common.XmlReader.ARRAY_SIZE_DIFFERENT",

"ARRAYSIZE attribute and value-array size are different");

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

}

property.setValue(value);

}

expectEndTag(parser, "PROPERTY.ARRAY");

}

return true;

}

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

// getHostElement()

// <!ELEMENT HOST (#PCDATA)>

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

Boolean XmlReader::getHostElement(

XmlParser& parser,

String& host)

{

XmlEntry entry;

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

return false;

if (!parser.next(entry) || entry.type != XmlEntry::CONTENT)

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_CONTENT_ELEMENT",

"expected content of HOST element");

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

}

host = String(entry.text);

expectEndTag(parser, "HOST");

return true;

}

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

// getNameSpaceElement()

// <!ELEMENT NAMESPACE EMPTY>

// <!ATTLIST NAMESPACE %CIMName;>

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

Boolean XmlReader::getNameSpaceElement(

XmlParser& parser,

CIMName& nameSpaceComponent)

{

XmlEntry entry;

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

return false;

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

nameSpaceComponent = getCimNameAttribute(

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

if (!empty)

expectEndTag(parser, "NAMESPACE");

return true;

}

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

// getLocalNameSpacePathElement()

// <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>

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

Boolean XmlReader::getLocalNameSpacePathElement(

XmlParser& parser,

String& nameSpace)

{

XmlEntry entry;

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

return false;

CIMName nameSpaceComponent;

while (getNameSpaceElement(parser, nameSpaceComponent))

{

if (nameSpace.size())

nameSpace.append('/');

nameSpace.append(nameSpaceComponent.getString());

}

if (!nameSpace.size())

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_NAMESPACE_ELEMENTS",

"Expected one or more NAMESPACE elements within "

"LOCALNAMESPACEPATH element");

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

}

expectEndTag(parser, "LOCALNAMESPACEPATH");

return true;

}

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

// getNameSpacePathElement()

// <!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>

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

Boolean XmlReader::getNameSpacePathElement(

XmlParser& parser,

String& host,

String& nameSpace)

{

host.clear();

nameSpace.clear();

XmlEntry entry;

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

return false;

if (!getHostElement(parser, host))

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_HOST_ELEMENT",

"expected HOST element");

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

}

if (!getLocalNameSpacePathElement(parser, nameSpace))

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",

"expected LOCALNAMESPACEPATH element");

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

}

expectEndTag(parser, "NAMESPACEPATH");

return true;

}

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

// getClassNameElement()

// <!ELEMENT CLASSNAME EMPTY>

// <!ATTLIST CLASSNAME %CIMName;>

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

Boolean XmlReader::getClassNameElement(

XmlParser& parser,

CIMName& className,

Boolean required)

{

XmlEntry entry;

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

{

if (required)

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",

"expected CLASSNAME element");

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

}

else

return false;

}

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

className = getCimNameAttribute(

parser.getLine(), entry, "CLASSNAME", false);

if (!empty)

expectEndTag(parser, "CLASSNAME");

return true;

}

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

// getValueTypeAttribute()

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

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

CIMKeyBinding::Type XmlReader::getValueTypeAttribute(

Uint32 lineNumber,

const char* tagName)

const XmlEntry& entry,

const char* elementName)

{

const char* tmp;

if (!entry.getAttributeValue("VALUETYPE", tmp))

return CIMKeyBinding::STRING;

if (strcmp(tmp, "string") == 0)

return CIMKeyBinding::STRING;

else if (strcmp(tmp, "boolean") == 0)

return CIMKeyBinding::BOOLEAN;

else if (strcmp(tmp, "numeric") == 0)

return CIMKeyBinding::NUMERIC;

char buffer[MESSAGE_SIZE];

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

MessageLoaderParms mlParms(

"Common.XmlReader.ILLEGAL_VALUE_FOR_CIMVALUE_ATTRIBUTE",

"Illegal value for $0 attribute; CIMValue must be one of \"string\", "

"\"boolean\", or \"numeric\"",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

return CIMKeyBinding::BOOLEAN;

}

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

// getKeyValueElement()

// <!ELEMENT KEYVALUE (#PCDATA)>

// <!ATTLIST KEYVALUE

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

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

Boolean XmlReader::getKeyValueElement(

XmlParser& parser,

CIMKeyBinding::Type& type,

String& value)

{

XmlEntry entry;

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

return false;

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

type = getValueTypeAttribute(parser.getLine(), entry, "KEYVALUE");

value.clear();

if (!empty)

{

if (!parser.next(entry))

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

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

value = String(entry.text);

else

parser.putBack(entry);

expectEndTag(parser, "KEYVALUE");

}

return true;

}

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

// getKeyBindingElement()

// <!ELEMENT KEYBINDING (KEYVALUE|VALUE.REFERENCE)>

// <!ATTLIST KEYBINDING

// %CIMName;>

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

Boolean XmlReader::getKeyBindingElement(

XmlParser& parser,

CIMName& name,

String& value,

CIMKeyBinding::Type& type)

{

XmlEntry entry;

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

return false;

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

if (!getKeyValueElement(parser, type, value))

{

CIMObjectPath reference;

if (!getValueReferenceElement(parser, reference))

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_KEYVALUE_OR_REFERENCE_ELEMENT",

"Expected KEYVALUE or VALUE.REFERENCE element");

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

}

type = CIMKeyBinding::REFERENCE;

value = reference.toString();

}

expectEndTag(parser, "KEYBINDING");

return true;

}

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

// getInstanceNameElement()

// <!ELEMENT INSTANCENAME (KEYBINDING*|KEYVALUE?|VALUE.REFERENCE?)>

// <!ATTLIST INSTANCENAME

// %ClassName;>

// Note: An empty key name is used in the keyBinding when the INSTANCENAME is

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

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

Boolean XmlReader::getInstanceNameElement(

XmlParser& parser,

String& className,

Array<CIMKeyBinding>& keyBindings)

{

// Get QUALIFIER.OVERRIDABLE

className.clear();

keyBindings.clear();

Boolean overridable = getCimBooleanAttribute(

XmlEntry entry;

lineNumber, entry, tagName, "OVERRIDABLE", true, false);

// Get QUALIFIER.TOSUBCLASS

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

return false;

Boolean toSubClass = getCimBooleanAttribute(

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

lineNumber, entry, tagName, "TOSUBCLASS", true, false);

// Get QUALIFIER.TOINSTANCE

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

Boolean toInstance = getCimBooleanAttribute(

if (empty)

lineNumber, entry, tagName, "TOINSTANCE", false, false);

{

return true;

}

// Get QUALIFIER.TRANSLATABLE

CIMName name;

CIMKeyBinding::Type type;

String value;

CIMObjectPath reference;

Boolean translatable = getCimBooleanAttribute(

if (getKeyValueElement(parser, type, value))

lineNumber, entry, tagName, "TRANSLATABLE", false, false);

{

// Use empty key name because none was specified

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

}

else if (getValueReferenceElement(parser, reference))

{

// Use empty key name because none was specified

type = CIMKeyBinding::REFERENCE;

value = reference.toString();

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

}

else

{

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

{

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

if (keyBindings.size() > PEGASUS_MAXELEMENTS_NUM)

{

MessageLoaderParms mlParms(

"Common.XmlReader.TOO_MANY_KEYBINDINGS",

"More than $0 key-value pairs per object path"

" are not supported.",

PEGASUS_MAXELEMENTS_NUM);

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

}

Uint32 flavor = 0;

expectEndTag(parser, "INSTANCENAME");

if (overridable)

return true;

flavor |= CIMFlavor::OVERRIDABLE;

}

if (toSubClass)

Boolean XmlReader::getInstanceNameElement(

flavor |= CIMFlavor::TOSUBCLASS;

XmlParser& parser,

CIMObjectPath& instanceName)

{

String className;

Array<CIMKeyBinding> keyBindings;

if (toInstance)

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

flavor |= CIMFlavor::TOINSTANCE;

return false;

if (translatable)

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

flavor |= CIMFlavor::TRANSLATABLE;

return true;

}

return flavor;

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

// getInstancePathElement()

// <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>

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

Boolean XmlReader::getInstancePathElement(

XmlParser& parser,

CIMObjectPath& reference)

{

XmlEntry entry;

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

return false;

String host;

String nameSpace;

if (!getNameSpacePathElement(parser, host, nameSpace))

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",

"expected NAMESPACEPATH element");

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

}

String className;

Array<CIMKeyBinding> keyBindings;

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

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",

"expected INSTANCENAME element");

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

}

reference.set(host, nameSpace, className, keyBindings);

expectEndTag(parser, "INSTANCEPATH");

return true;

}

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

// getOptionalScope()

// getLocalInstancePathElement()

// DTD:

// <!ELEMENT LOCALINSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>

// <!ELEMENT SCOPE EMPTY>

// <!ATTLIST SCOPE

// CLASS (true|false) 'false'

// ASSOCIATION (true|false) 'false'

// REFERENCE (true|false) 'false'

// PROPERTY (true|false) 'false'

// METHOD (true|false) 'false'

// PARAMETER (true|false) 'false'

// INDICATION (true|false) 'false'>

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

Uint32 XmlReader::getOptionalScope(XmlParser& parser)

Boolean XmlReader::getLocalInstancePathElement(

XmlParser& parser,

CIMObjectPath& reference)

{

XmlEntry entry;

if (!parser.next(entry))

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

return false;

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

String nameSpace;

if ((!isEmptyTag &&

if (!getLocalNameSpacePathElement(parser, nameSpace))

entry.type != XmlEntry::START_TAG) ||

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

{

parser.putBack(entry);

MessageLoaderParms mlParms(

return 0;

"Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",

"expected LOCALNAMESPACEPATH element");

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

}

Uint32 line = parser.getLine();

String className;

Uint32 scope = 0;

Array<CIMKeyBinding> keyBindings;

if (getCimBooleanAttribute(line, entry, "SCOPE", "CLASS", false, false))

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

scope |= CIMScope::CLASS;

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",

"expected INSTANCENAME element");

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

}

if (getCimBooleanAttribute(

reference.set(String(), nameSpace, className, keyBindings);

line, entry, "SCOPE", "ASSOCIATION", false, false))

scope |= CIMScope::ASSOCIATION;

if (getCimBooleanAttribute(

expectEndTag(parser, "LOCALINSTANCEPATH");

line, entry, "SCOPE", "REFERENCE", false, false))

return true;

scope |= CIMScope::REFERENCE;

}

if (getCimBooleanAttribute(line, entry, "SCOPE", "PROPERTY", false, false))

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

scope |= CIMScope::PROPERTY;

// getClassPathElement()

// <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>

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

if (getCimBooleanAttribute(line, entry, "SCOPE", "METHOD", false, false))

Boolean XmlReader::getClassPathElement(

scope |= CIMScope::METHOD;

XmlParser& parser,

CIMObjectPath& reference)

{

XmlEntry entry;

if (getCimBooleanAttribute(line, entry, "SCOPE", "PARAMETER", false, false))

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

scope |= CIMScope::PARAMETER;

return false;

if (getCimBooleanAttribute(line, entry, "SCOPE", "INDICATION",false, false))

String host;

scope |= CIMScope::INDICATION;

String nameSpace;

if (!isEmptyTag)

if (!getNameSpacePathElement(parser, host, nameSpace))

expectEndTag(parser, "SCOPE");

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_NAMESPACEPATH_ELEMENT",

"expected NAMESPACEPATH element");

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

}

CIMName className;

if (!getClassNameElement(parser, className))

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",

"expected CLASSNAME element");

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

}

reference.set(host, nameSpace, className);

expectEndTag(parser, "CLASSPATH");

return true;

}

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

// getLocalClassPathElement()

// <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH,CLASSNAME)>

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

Boolean XmlReader::getLocalClassPathElement(

XmlParser& parser,

CIMObjectPath& reference)

{

XmlEntry entry;

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

return false;

String nameSpace;

if (!getLocalNameSpacePathElement(parser, nameSpace))

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_LOCALNAMESPACEPATH_ELEMENT",

"expected LOCALNAMESPACEPATH element");

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

}

CIMName className;

if (!getClassNameElement(parser, className))

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_CLASSNAME_ELEMENT",

"expected CLASSNAME element");

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

}

reference.set(String(), nameSpace, className);

expectEndTag(parser, "LOCALCLASSPATH");

return true;

}

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

// getValueReferenceElement()

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

// INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>

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

// Parses the input to a CIMObjectPath. Note that today the differences

// between ClassPath and InstancePath are lost in this mapping because

// Pegasus uses the existence of keys as separator . See BUG_3302

Boolean XmlReader::getValueReferenceElement(

XmlParser& parser,

CIMObjectPath& reference)

{

XmlEntry entry;

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

return false;

if (!parser.next(entry))

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

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

entry.type != XmlEntry::EMPTY_TAG)

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_START_TAGS",

"Expected one of the following start tags: CLASSPATH, "

"LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, LOCALINSTANCEPATH, "

"INSTANCENAME");

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

}

if (strcmp(entry.text, "CLASSPATH") == 0)

{

parser.putBack(entry);

getClassPathElement(parser, reference);

}

else if (strcmp(entry.text, "LOCALCLASSPATH") == 0)

{

parser.putBack(entry);

getLocalClassPathElement(parser, reference);

}

else if (strcmp(entry.text, "CLASSNAME") == 0)

{

parser.putBack(entry);

CIMName className;

getClassNameElement(parser, className);

reference.set(String(), CIMNamespaceName(), className);

}

else if (strcmp(entry.text, "INSTANCEPATH") == 0)

{

parser.putBack(entry);

getInstancePathElement(parser, reference);

}

else if (strcmp(entry.text, "LOCALINSTANCEPATH") == 0)

{

parser.putBack(entry);

getLocalInstancePathElement(parser, reference);

}

else if (strcmp(entry.text, "INSTANCENAME") == 0)

{

parser.putBack(entry);

String className;

Array<CIMKeyBinding> keyBindings;

getInstanceNameElement(parser, className, keyBindings);

reference.set(String(), CIMNamespaceName(), className, keyBindings);

}

return scope;

expectEndTag(parser, "VALUE.REFERENCE");

return true;

}

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

// getQualifierElement()

// getValueReferenceArrayElement()

// <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)>

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

// <!ATTLIST QUALIFIER

// %CIMName;

// %CIMType; #REQUIRED

// %Propagated;

// %QualifierFlavor;>

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

Boolean XmlReader::getQualifierElement(

Boolean XmlReader::getValueReferenceArrayElement(

XmlParser& parser,

CIMQualifier& qualifier)

CIMValue& value)

{

// Get QUALIFIER element:

XmlEntry entry;

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

Array<CIMObjectPath> referenceArray;

return false;

CIMObjectPath reference;

// Get QUALIFIER.NAME attribute:

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

// Get QUALIFIER.TYPE attribute:

CIMType type = getCimTypeAttribute(parser.getLine(), entry, "QUALIFIER");

// Get QUALIFIER.PROPAGATED

Boolean propagated = getCimBooleanAttribute(

value.clear();

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

// Get flavor oriented attributes:

Uint32 flavor = getFlavor(entry, parser.getLine(), "QUALIFIER");

// Get VALUE.REFARRAY open tag:

// Get VALUE or VALUE.ARRAY element:

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

return false;

CIMValue value;

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

{

// For each VALUE.REFERENCE element:

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

while (getValueReferenceElement(parser, reference))

!getValueArrayElement(parser, type, value))

{

throw XmlSemanticError(parser.getLine(),

referenceArray.append(reference);

"Expected VALUE or VALUE.ARRAY element");

}

// Expect </QUALIFIER>:

expectEndTag(parser, "VALUE.REFARRAY");

expectEndTag(parser, "QUALIFIER");

// Build qualifier:

qualifier = CIMQualifier(name, value, flavor, propagated);

return true;

}

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

value.set(referenceArray);

return true;

// getQualifierElements()

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

template<class CONTAINER>

void getQualifierElements(XmlParser& parser, CONTAINER& container)

{

CIMQualifier qualifier;

while (XmlReader::getQualifierElement(parser, qualifier))

{

try

{

container.addQualifier(qualifier);

}

catch (AlreadyExists&)

{

throw XmlSemanticError(parser.getLine(), "duplicate qualifier");

}

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

// getPropertyElement()

// getPropertyReferenceElement()

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

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

// <!ATTLIST PROPERTY

// <!ATTLIST PROPERTY.REFERENCE

// %CIMName;

// %ReferenceClass;

// %ClassOrigin;

// %Propagated;

// %Propagated;>

// %CIMType; #REQUIRED>

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

Boolean XmlReader::getPropertyElement(XmlParser& parser, CIMProperty& property)

Boolean XmlReader::getPropertyReferenceElement(

XmlParser& parser,

CIMProperty& property)

{

XmlEntry entry;

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

if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY.REFERENCE"))

return false;

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

// Get PROPERTY.NAME attribute:

String name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");

CIMName name = getCimNameAttribute(

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

// Get PROPERTY.CLASSORIGIN attribute:

// Get PROPERTY.REFERENCECLASS attribute:

String classOrigin =

CIMName referenceClass = getReferenceClassAttribute(

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

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

// Get PROPERTY.PROPAGATED

// Get PROPERTY.CLASSORIGIN attribute:

Boolean propagated = getCimBooleanAttribute(

CIMName classOrigin =

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

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

// Get PROPERTY.TYPE attribute:

// Get PROPERTY.PROPAGATED

CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY");

Boolean propagated = getCimBooleanAttribute(parser.getLine(), entry,

"PROPERTY.REFERENCE", "PROPAGATED", false, false);

// Create property:

CIMValue value;

CIMValue value = CIMValue(CIMTYPE_REFERENCE, false, 0);

value.setNullValue(type, false);

// value.set(CIMObjectPath());

property = CIMProperty(

name, value, 0, String(), classOrigin, propagated);

name, value, 0, referenceClass, classOrigin, propagated);

if (!empty)

{

// Get qualifiers:

getQualifierElements(parser, property);

// Get value:

CIMObjectPath reference;

if (getValueElement(parser, type, value))

if (getValueReferenceElement(parser, reference))

property.setValue(value);

property.setValue(reference);

expectEndTag(parser, "PROPERTY");

expectEndTag(parser, "PROPERTY.REFERENCE");

}

return true;

Line 1349

Line 2982

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

// getArraySizeAttribute()

// GetPropertyElements()

// Returns true if able to get array-size. Note that array size will

// always be a positive integer.

// <!ENTITY % ArraySize "ARRAYSIZE CDATA #IMPLIED">

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

Boolean XmlReader::getArraySizeAttribute(

template<class CONTAINER>

Uint32 lineNumber,

void GetPropertyElements(XmlParser& parser, CONTAINER& container)

const XmlEntry& entry,

const char* tagName,

Uint32& value)

{

const char* tmp;

CIMProperty property;

if (!entry.getAttributeValue("ARRAYSIZE", tmp))

return false;

Uint64 arraySize;

if (!stringToUnsignedInteger(tmp, arraySize) || arraySize == 0)

while (XmlReader::getPropertyElement(parser, property) ||

XmlReader::getPropertyArrayElement(parser, property) ||

XmlReader::getPropertyReferenceElement(parser, property))

{

char message[128];

try

sprintf(message, "Illegal value for %s.%s", tagName, "ARRAYSIZE");

{

throw XmlSemanticError(lineNumber, message);

container.addProperty(property);

}

catch (AlreadyExistsException&)

{

MessageLoaderParms mlParms(

"Common.XmlReader.DUPLICATE_PROPERTY",

"duplicate property");

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

}

value = Uint32(arraySize);

return true;

}

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

// getPropertyArrayElement()

// getParameterElement()

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

// <!ELEMENT PARAMETER (QUALIFIER*)>

// <!ATTLIST PROPERTY.ARRAY

// <!ATTLIST PARAMETER

// %CIMName;

// %CIMType; #REQUIRED

// %CIMType; #REQUIRED>

// %ArraySize;

// %ClassOrigin;

// %Propagated;>

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

Boolean XmlReader::getPropertyArrayElement(

Boolean XmlReader::getParameterElement(

XmlParser& parser,

CIMProperty& property)

CIMParameter& parameter)

{

// Get PROPERTY element:

XmlEntry entry;

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

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

return false;

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

// Get PROPERTY.NAME attribute:

// Get PARAMETER.NAME attribute:

String name =

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

// Get PROPERTY.TYPE attribute:

CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY.ARRAY");

// Get PROPERTY.ARRAYSIZE attribute:

Uint32 arraySize = 0;

getArraySizeAttribute(parser.getLine(), entry, "PROPERTY.ARRAY", arraySize);

// Get PROPERTY.CLASSORIGIN attribute:

String classOrigin

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

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

// Get PROPERTY.ARRAY.PROPAGATED

// Get PARAMETER.TYPE attribute:

Boolean propagated = getCimBooleanAttribute(

CIMType type;

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

getCimTypeAttribute(parser.getLine(), entry, type, "PARAMETER");

// Create property:

// Create parameter:

CIMValue nullValue;

parameter = CIMParameter(name, type);

nullValue.setNullValue(type, true, arraySize);

property = CIMProperty(

name, nullValue, arraySize, String(), classOrigin, propagated);

if (!empty)

{

// Get qualifiers:

getQualifierElements(parser, parameter);

getQualifierElements(parser, property);

// Get value:

CIMValue value;

if (getValueArrayElement(parser, type, value))

{

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

{

throw XmlSemanticError(parser.getLine(),

"ARRAYSIZE attribute and value-array size are different");

}

property.setValue(value);

}

expectEndTag(parser, "PROPERTY.ARRAY");

expectEndTag(parser, "PARAMETER");

}

return true;

Line 1469

Line 3056

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

// getHostElement()

// getParameterArrayElement()

// <!ELEMENT HOST (#PCDATA)>

// <!ELEMENT PARAMETER.ARRAY (QUALIFIER*)>

// <!ATTLIST PARAMETER.ARRAY

// %CIMName;

// %CIMType; #REQUIRED

// %ArraySize;>

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

Boolean XmlReader::getHostElement(

Boolean XmlReader::getParameterArrayElement(

XmlParser& parser,

String& host)

CIMParameter& parameter)

{

XmlEntry entry;

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

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

return false;

if (!parser.next(entry) || entry.type != XmlEntry::CONTENT)

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

// Get PARAMETER.ARRAY.NAME attribute:

CIMName name = getCimNameAttribute(

parser.getLine(), entry, "PARAMETER.ARRAY");

// Get PARAMETER.ARRAY.TYPE attribute:

CIMType type;

getCimTypeAttribute(parser.getLine(), entry, type, "PARAMETER.ARRAY");

// Get PARAMETER.ARRAYSIZE attribute:

Uint32 arraySize = 0;

getArraySizeAttribute(parser.getLine(), entry, "PARAMETER.ARRAY",arraySize);

// Create parameter:

parameter = CIMParameter(name, type, true, arraySize);

if (!empty)

{

throw XmlValidationError(parser.getLine(),

getQualifierElements(parser, parameter);

"expected content of HOST element");

}

host = entry.text;

expectEndTag(parser, "PARAMETER.ARRAY");

}

expectEndTag(parser, "HOST");

return true;

}

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

// getNameSpaceElement()

// getParameterReferenceElement()

// <!ELEMENT NAMESPACE EMPTY>

// <!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)>

// <!ATTLIST NAMESPACE %CIMName;>

// <!ATTLIST PARAMETER.REFERENCE

// %CIMName;

// %ReferenceClass;>

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

Boolean XmlReader::getNameSpaceElement(

Boolean XmlReader::getParameterReferenceElement(

XmlParser& parser,

String& nameSpaceComponent)

CIMParameter& parameter)

{

XmlEntry entry;

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

if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFERENCE"))

return false;

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

nameSpaceComponent = getCimNameAttribute(

// Get PARAMETER.NAME attribute:

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

CIMName name = getCimNameAttribute(

parser.getLine(), entry, "PARAMETER.REFERENCE");

// Get PARAMETER.REFERENCECLASS attribute:

CIMName referenceClass = getReferenceClassAttribute(

parser.getLine(), entry, "PARAMETER.REFERENCE");

// Create parameter:

parameter = CIMParameter(name, CIMTYPE_REFERENCE, false, 0, referenceClass);

if (!empty)

expectEndTag(parser, "NAMESPACE");

{

getQualifierElements(parser, parameter);

expectEndTag(parser, "PARAMETER.REFERENCE");

}

return true;

}

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

// getLocalNameSpacePathElement()

// getParameterReferenceArrayElement()

// <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>

// <!ELEMENT PARAMETER.REFARRAY (QUALIFIER*)>

// <!ATTLIST PARAMETER.REFARRAY

// %CIMName;

// %ReferenceClass;

// %ArraySize;>

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

Boolean XmlReader::getLocalNameSpacePathElement(

Boolean XmlReader::getParameterReferenceArrayElement(

XmlParser& parser,

String& nameSpace)

CIMParameter& parameter)

{

XmlEntry entry;

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

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

return false;

String nameSpaceComponent;

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

while (getNameSpaceElement(parser, nameSpaceComponent))

// Get PARAMETER.NAME attribute:

{

if (nameSpace.getLength())

nameSpace += '/';

nameSpace += nameSpaceComponent;

CIMName name = getCimNameAttribute(

}

parser.getLine(), entry, "PARAMETER.REFARRAY");

// Get PARAMETER.REFERENCECLASS attribute:

CIMName 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 (!nameSpace.getLength())

if (!empty)

{

throw XmlValidationError(parser.getLine(),

getQualifierElements(parser, parameter);

"Expected one or more NAMESPACE elements within "

expectEndTag(parser, "PARAMETER.REFARRAY");

"LOCALNAMESPACEPATH element");

}

expectEndTag(parser, "LOCALNAMESPACEPATH");

return true;

}

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

// getNameSpacePathElement()

// GetParameterElements()

// <!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>

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

Boolean XmlReader::getNameSpacePathElement(

template<class CONTAINER>

XmlParser& parser,

void GetParameterElements(XmlParser& parser, CONTAINER& container)

String& host,

String& nameSpace)

{

host.clear();

CIMParameter parameter;

nameSpace.clear();

XmlEntry entry;

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

return false;

if (!getHostElement(parser, host))

throw XmlValidationError(parser.getLine(), "expected HOST element");

if (!getLocalNameSpacePathElement(parser, nameSpace))

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

XmlReader::getParameterArrayElement(parser, parameter) ||

XmlReader::getParameterReferenceElement(parser, parameter) ||

XmlReader::getParameterReferenceArrayElement(parser, parameter))

{

throw XmlValidationError(parser.getLine(),

try

"expected LOCALNAMESPACEPATH element");

{

container.addParameter(parameter);

}

catch (AlreadyExistsException&)

{

MessageLoaderParms mlParms(

"Common.XmlReader.DUPLICATE_PARAMETER",

"duplicate parameter");

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

}

expectEndTag(parser, "NAMESPACEPATH");

return true;

}

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

// getClassNameElement()

// getQualifierDeclElement()

// <!ELEMENT CLASSNAME EMPTY>

// <!ELEMENT QUALIFIER.DECLARATION (SCOPE?,(VALUE|VALUE.ARRAY)?)>

// <!ATTLIST CLASSNAME %CIMName;>

// <!ATTLIST QUALIFIER.DECLARATION

// %CIMName;

// %CIMType; #REQUIRED

// ISARRAY (true|false) #IMPLIED

// %ArraySize;

// %QualifierFlavor;>

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

Boolean XmlReader::getClassNameElement(

Boolean XmlReader::getQualifierDeclElement(

XmlParser& parser,

String& className,

CIMQualifierDecl& qualifierDecl)

Boolean required)

{

XmlEntry entry;

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

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

{

if (required)

{

throw XmlValidationError(parser.getLine(),

"expected CLASSNAME element");

}

else

return false;

}

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

className = getCimNameAttribute(

// Get NAME attribute:

parser.getLine(), entry, "CLASSNAME", true);

CIMName name = getCimNameAttribute(

parser.getLine(), entry, "QUALIFIER.DECLARATION");

// Get TYPE attribute:

CIMType type;

getCimTypeAttribute(parser.getLine(), entry, type, "QUALIFIER.DECLARATION");

// Get ISARRAY attribute:

Boolean isArray = getCimBooleanAttribute(

parser.getLine(), entry, "QUALIFIER.DECLARATION", "ISARRAY",

false, false);

// Get ARRAYSIZE attribute:

Uint32 arraySize = 0;

getArraySizeAttribute(parser.getLine(),

entry, "QUALIFIER.DECLARATION", arraySize);

// Get flavor oriented attributes:

CIMFlavor flavor = getFlavor (entry, parser.getLine (),

"QUALIFIER.DECLARATION");

// No need to look for interior elements if empty tag:

CIMScope scope = CIMScope ();

CIMValue value;

Boolean gotValue = false;

if (!empty)

expectEndTag(parser, "CLASSNAME");

{

// Get the option SCOPE element:

return true;

scope = getOptionalScope(parser);

// Get VALUE or VALUE.ARRAY element:

if (getValueArrayElement(parser, type, value))

{

if (!isArray)

{

MessageLoaderParms mlParms(

"Common.XmlReader.ARRAY_WITHOUT_ISARRAY",

"VALUE.ARRAY element encountered without ISARRAY "

"attribute");

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

}

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

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

{

// getValueTypeAttribute()

MessageLoaderParms mlParms(

"Common.XmlReader.ARRAY_SIZE_NOT_SAME",

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

"VALUE.ARRAY size is not the same as ARRAYSIZE attribute");

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

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

}

KeyBinding::CIMType XmlReader::getValueTypeAttribute(

gotValue = true;

Uint32 lineNumber,

}

const XmlEntry& entry,

else if (getValueElement(parser, type, value))

const char* elementName)

{

if (isArray)

{

String tmp;

MessageLoaderParms mlParms(

"Common.XmlReader.ARRAY_ATTRIBUTE_DIFFERENT",

"ISARRAY attribute used but VALUE element encountered");

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

}

if (!entry.getAttributeValue("VALUETYPE", tmp))

gotValue = true;

return KeyBinding::STRING;

}

if (String::equal(tmp, "string"))

// Now get the closing tag:

return KeyBinding::STRING;

else if (String::equal(tmp, "boolean"))

return KeyBinding::BOOLEAN;

else if (String::equal(tmp, "numeric"))

return KeyBinding::NUMERIC;

char buffer[MESSAGE_SIZE];

expectEndTag(parser, "QUALIFIER.DECLARATION");

}

sprintf(buffer,

if (!gotValue)

"Illegal value for %s.VALUETYPE attribute; "

{

"CIMValue must be one of \"string\", \"boolean\", or \"numeric\"",

if (isArray)

elementName);

value.setNullValue(type, true, arraySize);

else

value.setNullValue(type, false);

}

throw XmlSemanticError(lineNumber, buffer);

CIMQualifierDecl tmp(name, value, scope, flavor, arraySize);

return KeyBinding::BOOLEAN;

qualifierDecl = CIMQualifierDecl(name, value, scope, flavor, arraySize);

return true;

}

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

// getMethodElement()

// getKeyValueElement()

// <!ELEMENT METHOD (QUALIFIER*,(PARAMETER|PARAMETER.REFERENCE|

// PARAMETER.ARRAY|PARAMETER.REFARRAY)*)>

// <!ELEMENT KEYVALUE (#PCDATA)>

// <!ATTLIST METHOD

// <!ATTLIST KEYVALUE

// %CIMName;

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

// %CIMType; #IMPLIED

// %ClassOrigin;

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

// %Propagated;>

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

Boolean XmlReader::getKeyValueElement(

Boolean XmlReader::getMethodElement(XmlParser& parser, CIMMethod& method)

XmlParser& parser,

KeyBinding::CIMType& type,

String& value)

{

XmlEntry entry;

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

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

return false;

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

type = getValueTypeAttribute(parser.getLine(), entry, "KEYVALUE");

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

value.clear();

CIMType type;

getCimTypeAttribute(parser.getLine(), entry, type, "METHOD");

CIMName classOrigin =

getClassOriginAttribute(parser.getLine(), entry, "METHOD");

Boolean propagated = getCimBooleanAttribute(

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

method = CIMMethod(name, type, classOrigin, propagated);

if (!empty)

{

if (!parser.next(entry))

// ATTN-RK-P2-20020219: Decoding algorithm must not depend on the

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

// ordering of qualifiers and parameters.

getQualifierElements(parser, method);

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

GetParameterElements(parser, method);

value = entry.text;

else

parser.putBack(entry);

expectEndTag(parser, "KEYVALUE");

expectEndTag(parser, "METHOD");

}

return true;

}

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

// getClassElement()

// getKeyBindingElement()

// <!ELEMENT CLASS (QUALIFIER*,

// (PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,METHOD*)>

// <!ELEMENT KEYBINDING (KEYVALUE|VALUE.REFERENCE)>

// <!ATTLIST CLASS %CIMName; %SuperClass;>

// <!ATTLIST KEYBINDING

// %CIMName;>

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

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

Boolean XmlReader::getKeyBindingElement(

Boolean XmlReader::getClassElement(XmlParser& parser, CIMClass& cimClass)

XmlParser& parser,

String& name,

String& value,

KeyBinding::CIMType& type)

{

XmlEntry entry;

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

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

return false;

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

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

if (!getKeyValueElement(parser, type, value))

CIMName superClass =

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

getSuperClassAttribute(parser.getLine(), entry,"CLASS");

cimClass = CIMClass(name, superClass);

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

{

// Get QUALIFIER elements:

getQualifierElements(parser, cimClass);

// Get PROPERTY elements:

GetPropertyElements(parser, cimClass);

// Get METHOD elements:

CIMMethod method;

while (getMethodElement(parser, method))

cimClass.addMethod(method);

// Get CLASS end tag:

expectEndTag(parser, "CLASS");

}

expectEndTag(parser, "KEYBINDING");

return true;

}

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

// getInstanceElement()

// getInstanceNameElement()

// <!ELEMENT INSTANCE (QUALIFIER*,

// (PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*) >

// <!ELEMENT INSTANCENAME (KEYBINDING*|KEYVALUE?|VALUE.REFERENCE?)>

// <!ATTLIST INSTANCE

// <!ATTLIST INSTANCENAME

// %ClassName;>

// ATTN-B: VALUE.REFERENCE sub-element not accepted yet.

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

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

Boolean XmlReader::getInstanceNameElement(

Boolean XmlReader::getInstanceElement(

XmlParser& parser,

String& className,

CIMInstance& cimInstance)

Array<KeyBinding>& keyBindings)

{

className.clear();

keyBindings.clear();

XmlEntry entry;

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

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

return false;

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

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

String className = getClassNameAttribute(

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

cimInstance = CIMInstance(className);

if (!empty)

{

String name;

// Get QUALIFIER elements:

KeyBinding::CIMType type;

getQualifierElements(parser, cimInstance);

String value;

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

// Get PROPERTY elements:

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

GetPropertyElements(parser, cimInstance);

if (!empty)

// Get INSTANCE end tag:

expectEndTag(parser, "INSTANCENAME");

expectEndTag(parser, "INSTANCE");

}

return true;

}

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

// getNamedInstanceElement()

// getInstancePathElement()

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

// <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>

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

Boolean XmlReader::getInstancePathElement(

Boolean XmlReader::getNamedInstanceElement(

XmlParser& parser,

CIMReference& reference)

CIMInstance& namedInstance)

{

XmlEntry entry;

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

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

return false;

String host;

CIMObjectPath instanceName;

String nameSpace;

if (!getNameSpacePathElement(parser, host, nameSpace))

// Get INSTANCENAME elements:

if (!getInstanceNameElement(parser, instanceName))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"expected NAMESPACEPATH element");

"Common.XmlReader.EXPECTED_INSTANCENAME_ELEMENT",

"expected INSTANCENAME element");

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

}

String className;

// Get INSTANCE elements:

Array<KeyBinding> keyBindings;

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

if (!getInstanceElement(parser, namedInstance))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"expected INSTANCENAME element");

"Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"expected INSTANCE element");

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

}

reference.set(host, nameSpace, className, keyBindings);

// Get VALUE.NAMEDINSTANCE end tag:

expectEndTag(parser, "VALUE.NAMEDINSTANCE");

namedInstance.setPath (instanceName);

expectEndTag(parser, "INSTANCEPATH");

return true;

}

//EXP_PULL_BEGIN

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

// getInstanceWithPathElement()

// getLocalInstancePathElement()

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

// <!ELEMENT LOCALINSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>

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

Boolean XmlReader::getLocalInstancePathElement(

Boolean XmlReader::getInstanceWithPathElement(

XmlParser& parser,

CIMReference& reference)

CIMInstance& namedInstance)

{

XmlEntry entry;

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

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

return false;

String nameSpace;

CIMObjectPath instanceName;

if (!getLocalNameSpacePathElement(parser, nameSpace))

// Get INSTANCENAME elements:

if (!getInstancePathElement(parser, instanceName))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"expected LOCALNAMESPACEPATH element");

"Common.XmlReader.EXPECTED_INSTANCEPATH_ELEMENT",

"expected INSTANCEPATH element");

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

}

String className;

// Get INSTANCE elements:

Array<KeyBinding> keyBindings;

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

if (!getInstanceElement(parser, namedInstance))

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"expected INSTANCENAME element");

"Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"expected INSTANCE element");

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

}

// Get VALUE.NAMEDINSTANCE end tag:

reference.set(String(), nameSpace, className, keyBindings);

expectEndTag(parser, "VALUE.INSTANCEWITHPATH");

namedInstance.setPath (instanceName);

expectEndTag(parser, "LOCALINSTANCEPATH");

return true;

}

//EXP_PULL_END

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

// getClassPathElement()

// getObject()

// <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>

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

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

{

if (!getClassElement(parser, x))

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_CLASS_ELEMENT",

"expected CLASS element");

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

}

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

// getObject()

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

Boolean XmlReader::getClassPathElement(

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

{

if (!getInstanceElement(parser, x))

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"expected INSTANCE element");

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

}

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

// getObject()

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

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

{

if (!getQualifierDeclElement(parser, x))

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_QUALIFIER_DECLARATION_ELEMENT",

"expected QUALIFIER.DECLARATION element");

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

}

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

// getMessageStartTag()

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

Boolean XmlReader::getMessageStartTag(

XmlParser& parser,

CIMReference& reference)

String& id,

String& protocolVersion)

{

XmlEntry entry;

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

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

return false;

String host;

// Get MESSAGE.ID:

String nameSpace;

if (!getNameSpacePathElement(parser, host, nameSpace))

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

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"expected NAMESPACEPATH element");

"Common.XmlReader.INVALID_MISSING_MESSAGE_ID_ATTRIBUTE",

"Invalid or missing MESSAGE.ID attribute");

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

}

String className;

if (!getClassNameElement(parser, className))

// Get MESSAGE.PROTOCOLVERSION:

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

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"expected CLASSNAME element");

"Common.XmlReader.INVALID_MISSING_PROTOCOLVERSION_ATTRIBUTE",

"Invalid or missing MESSAGE.PROTOCOLVERSION attribute");

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

}

reference.set(host, nameSpace, className);

expectEndTag(parser, "CLASSPATH");

return true;

}

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

// getLocalClassPathElement()

// getIMethodCallStartTag()

// <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH,CLASSNAME)>

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

Boolean XmlReader::getLocalClassPathElement(

Boolean XmlReader::getIMethodCallStartTag(

XmlParser& parser,

CIMReference& reference)

const char*& name)

{

XmlEntry entry;

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

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

return false;

String nameSpace;

// Get IMETHODCALL.NAME attribute:

if (!getLocalNameSpacePathElement(parser, nameSpace))

{

throw XmlValidationError(parser.getLine(),

"expected LOCALNAMESPACEPATH element");

}

String className;

if (!getClassNameElement(parser, className))

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

{

throw XmlValidationError(parser.getLine(),

MessageLoaderParms mlParms(

"expected CLASSNAME element");

"Common.XmlReader.MISSING_IMETHODCALL_ATTRIBUTE",

"Missing IMETHODCALL.NAME attribute");

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

}

reference.set(String(), nameSpace, className);

expectEndTag(parser, "LOCALCLASSPATH");

return true;

}

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

// getValueReferenceElement()

// getIMethodResponseStartTag()

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

// INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>

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

Boolean XmlReader::getValueReferenceElement(

Boolean XmlReader::getIMethodResponseStartTag(

XmlParser& parser,

CIMReference& reference)

const char*& name,

Boolean& isEmptyTag)

{

XmlEntry entry;

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

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

return false;

if (!parser.next(entry))

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

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

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

// Get IMETHODRESPONSE.NAME attribute:

entry.type != XmlEntry::EMPTY_TAG)

{

throw XmlValidationError(parser.getLine(),

"Expected one of the following start tags: "

"CLASSPATH, LOCALCLASSPATH, CLASSNAME, INSTANCEPATH, "

"LOCALINSTANCEPATH, INSTANCENAME");

}

if (strcmp(entry.text, "CLASSPATH") == 0)

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

{

parser.putBack(entry);

getClassPathElement(parser, reference);

}

else if (strcmp(entry.text, "LOCALCLASSPATH") == 0)

{

parser.putBack(entry);

getLocalClassPathElement(parser, reference);

}

else if (strcmp(entry.text, "CLASSNAME") == 0)

{

parser.putBack(entry);

String className;

getClassNameElement(parser, className);

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

}

else if (strcmp(entry.text, "INSTANCEPATH") == 0)

{

parser.putBack(entry);

getInstancePathElement(parser, reference);

}

else if (strcmp(entry.text, "LOCALINSTANCEPATH") == 0)

{

parser.putBack(entry);

getLocalInstancePathElement(parser, reference);

}

else if (strcmp(entry.text, "INSTANCENAME") == 0)

{

parser.putBack(entry);

MessageLoaderParms mlParms(

String className;

"Common.XmlReader.MISSING_IMETHODRESPONSE_ATTRIBUTE",

Array<KeyBinding> keyBindings;

"Missing IMETHODRESPONSE.NAME attribute");

getInstanceNameElement(parser, className, keyBindings);

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

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

}

expectEndTag(parser, "VALUE.REFERENCE");

return true;

}

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

// getPropertyReferenceElement()

// getIParamValueTag()

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

// <!ATTLIST PROPERTY.REFERENCE

// %CIMName;

// %ReferenceClass;

// %ClassOrigin;

// %Propagated;>

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

Boolean XmlReader::getPropertyReferenceElement(

Boolean XmlReader::getIParamValueTag(

XmlParser& parser,

CIMProperty& property)

const char*& name,

Boolean& isEmptyTag)

{

XmlEntry entry;

if (!testStartTagOrEmptyTag(parser, entry, "PROPERTY.REFERENCE"))

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

return false;

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

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

// Get PROPERTY.NAME attribute:

String name = getCimNameAttribute(

// Get IPARAMVALUE.NAME attribute:

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

// Get PROPERTY.REFERENCECLASS attribute:

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

{

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_IPARAMVALUE_ATTRIBUTE",

"Missing IPARAMVALUE.NAME attribute");

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

}

String referenceClass = getReferenceClassAttribute(

return true;

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

}

// Get PROPERTY.CLASSORIGIN attribute:

//EXP_PULL_BEGIN

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

// getIParamValueTag()

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

String classOrigin =

Boolean XmlReader::getParamValueTag(

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

XmlParser& parser,

const char*& name,

Boolean& isEmptyTag)

{

XmlEntry entry;

// Get PROPERTY.PROPAGATED

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

{

Boolean propagated = getCimBooleanAttribute(parser.getLine(), entry,

return false;

"PROPERTY.REFERENCE", "PROPAGATED", false, false);

}

// Create property:

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

CIMValue value;

// Get PARAMVALUE.NAME attribute:

value.set(CIMReference());

property = CIMProperty(

name, value, 0, referenceClass, classOrigin, propagated);

if (!empty)

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

{

getQualifierElements(parser, property);

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_PARAMVALUE_ATTRIBUTE",

CIMReference reference;

"Missing PARAMVALUE.NAME attribute");

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

}

return true;

}

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

// getIReturnValueTag()

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

if (getValueReferenceElement(parser, reference))

Boolean XmlReader::getIReturnValueTag(

property.setValue(reference);

XmlParser& parser,

const char*& name,

Boolean& isEmptyTag)

{

XmlEntry entry;

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

return false;

//entry.print();

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

expectEndTag(parser, "PROPERTY.REFERENCE");

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

{

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_IRETURNVALUE_ATTRIBUTE",

"Missing IRETURNVALUE.NAME attribute");

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

}

return true;

}

//EXP_PULL_END

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

// GetPropertyElements()

// rejectNullIParamValue()

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

template<class CONTAINER>

void XmlReader::rejectNullIParamValue(

void GetPropertyElements(XmlParser& parser, CONTAINER& container)

XmlParser& parser,

{

Boolean isEmptyTag,

CIMProperty property;

const char* paramName)

while (XmlReader::getPropertyElement(parser, property) ||

XmlReader::getPropertyArrayElement(parser, property) ||

XmlReader::getPropertyReferenceElement(parser, property))

{

try

{

container.addProperty(property);

if (isEmptyTag)

}

catch (AlreadyExists&)

{

throw XmlSemanticError(parser.getLine(), "duplicate property");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_NULL_IPARAMVALUE",

}

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

paramName);

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

}

// EXP_PULL_BEGIN

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

// getParameterElement()

// rejectNullIReturnParamValue()

// <!ELEMENT PARAMETER (QUALIFIER*)>

// <!ATTLIST PARAMETER

// %CIMName;

// %CIMType; #REQUIRED>

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

Boolean XmlReader::getParameterElement(

void XmlReader::rejectNullIReturnValue(

XmlParser& parser,

CIMParameter& parameter)

Boolean isEmptyTag,

const char* paramName)

{

XmlEntry entry;

if (isEmptyTag)

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

return false;

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

// Get PARAMETER.NAME attribute:

String name = getCimNameAttribute(parser.getLine(), entry, "PARAMETER");

// Get PARAMETER.TYPE attribute:

CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PARAMETER");

// Create parameter:

parameter = CIMParameter(name, type);

if (!empty)

{

getQualifierElements(parser, parameter);

MessageLoaderParms mlParms("Common.XmlReader.INVALID_NULL_IRETURNVALUE",

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

expectEndTag(parser, "PARAMETER");

paramName);

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

}

return true;

}

void XmlReader::rejectNullParamValue(

XmlParser& parser,

Boolean isEmptyTag,

const char* paramName)

{

if (isEmptyTag)

{

MessageLoaderParms mlParms("Common.XmlReader.INVALID_NULL_PARAMVALUE",

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

paramName);

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

}

// EXP_PULL_END

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

// getParameterArrayElement()

// getBooleanValueElement()

// <!ELEMENT PARAMETER.ARRAY (QUALIFIER*)>

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

// <!ATTLIST PARAMETER.ARRAY

// %CIMName;

// %CIMType; #REQUIRED

// %ArraySize;>

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

Boolean XmlReader::getParameterArrayElement(

Boolean XmlReader::getBooleanValueElement(

XmlParser& parser,

CIMParameter& parameter)

Boolean& result,

Boolean required)

{

XmlEntry entry;

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

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

{

if (required)

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_VALUE_ELEMENT",

"Expected VALUE element");

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

}

return false;

}

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

expectContentOrCData(parser, entry);

// Get PARAMETER.ARRAY.NAME attribute:

String name = getCimNameAttribute(

parser.getLine(), entry, "PARAMETER.ARRAY");

// Get PARAMETER.ARRAY.TYPE attribute:

CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PARAMETER.ARRAY");

// Get PARAMETER.ARRAYSIZE attribute:

Uint32 arraySize = 0;

getArraySizeAttribute(parser.getLine(), entry, "PARAMETER.ARRAY",arraySize);

// Create parameter:

parameter = CIMParameter(name, type, true, arraySize);

if (!empty)

if (System::strcasecmp(entry.text, "TRUE") == 0)

result = true;

else if (System::strcasecmp(entry.text, "FALSE") == 0)

result = false;

else

{

getQualifierElements(parser, parameter);

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_VALUE_FOR_VALUE_ELEMENT",

expectEndTag(parser, "PARAMETER.ARRAY");

"Invalid value for VALUE element: must be \"TRUE\" or \"FALSE\"");

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

}

expectEndTag(parser, "VALUE");

return true;

}

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

// getParameterReferenceElement()

// DMTF CR Pending

// <!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)>

// <!ELEMENT ERROR (INSTANCE*)>

// <!ATTLIST PARAMETER.REFERENCE

// <!ATTLIST ERROR

// %CIMName;

// CODE CDATA #REQUIRED

// %ReferenceClass;>

// DESCRIPTION CDATA #IMPLIED>

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

Boolean XmlReader::getParameterReferenceElement(

Boolean XmlReader::getErrorElement(

XmlParser& parser,

CIMParameter& parameter)

CIMException& cimException,

Boolean required)

{

XmlEntry entry;

if (!testStartTagOrEmptyTag(parser, entry, "PARAMETER.REFERENCE"))

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

{

if (required)

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_ERROR_ELEMENT",

"Expected ERROR element");

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

}

return false;

}

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

// Get PARAMETER.NAME attribute:

// Get ERROR.CODE

String name = getCimNameAttribute(

Uint32 tmpCode;

parser.getLine(), entry, "PARAMETER.REFERENCE");

// Get PARAMETER.REFERENCECLASS attribute:

if (!entry.getAttributeValue("CODE", tmpCode))

{

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_ERROR_CODE_ATTRIBUTE",

"missing ERROR.CODE attribute");

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

}

String referenceClass = getReferenceClassAttribute(

// Get ERROR.DESCRIPTION:

parser.getLine(), entry, "PARAMETER.REFERENCE");

// Create parameter:

String tmpDescription;

parameter = CIMParameter(name, CIMType::REFERENCE, false, 0, referenceClass);

entry.getAttributeValue("DESCRIPTION", tmpDescription);

cimException =

PEGASUS_CIM_EXCEPTION(CIMStatusCode(tmpCode), tmpDescription);

if (!empty)

{

getQualifierElements(parser, parameter);

CIMInstance instance;

expectEndTag(parser, "PARAMETER.REFERENCE");

while (getInstanceElement(parser, instance))

{

cimException.addError(instance);

}

expectEndTag(parser, "ERROR");

}

return true;

}

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

// getValueObjectElement()

// GetParameterElements()

// <!ELEMENT VALUE.OBJECT (CLASS|INSTANCE)>

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

template<class CONTAINER>

Boolean XmlReader::getValueObjectElement(

void GetParameterElements(XmlParser& parser, CONTAINER& container)

XmlParser& parser,

CIMObject& object)

{

CIMParameter parameter;

XmlEntry entry;

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

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

XmlReader::getParameterArrayElement(parser, parameter) ||

return false;

XmlReader::getParameterReferenceElement(parser, parameter))

{

CIMInstance cimInstance;

try

CIMClass cimClass;

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

{

container.addParameter(parameter);

object = CIMObject(cimInstance);

}

catch (AlreadyExists&)

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

{

throw XmlSemanticError(parser.getLine(), "duplicate parameter");

object = CIMObject(cimClass);

}

else

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",

"Expected INSTANCE or CLASS element");

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

}

expectEndTag(parser, "VALUE.OBJECT");

return true;

}

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

// getValueObjectWithPathElement()

// getQualifierDeclElement()

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

// <!ELEMENT QUALIFIER.DECLARATION (SCOPE?,(VALUE|VALUE.ARRAY)?)>

// <!ATTLIST QUALIFIER.DECLARATION

// %CIMName;

// %CIMType; #REQUIRED

// ISARRAY (true|false) #IMPLIED

// %ArraySize;

// %QualifierFlavor;>

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

Boolean XmlReader::getQualifierDeclElement(

Boolean XmlReader::getValueObjectWithPathElement(

XmlParser& parser,

CIMQualifierDecl& qualifierDecl)

CIMObject& objectWithPath)

{

XmlEntry entry;

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

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

return false;

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

CIMObjectPath reference;

Boolean isInstance = false;

// Get NAME attribute:

String name = getCimNameAttribute(

parser.getLine(), entry, "QUALIFIER.DECLARATION");

// Get TYPE attribute:

CIMType type = getCimTypeAttribute(

parser.getLine(), entry, "QUALIFIER.DECLARATION");

// Get ISARRAY attribute:

Boolean isArray = false;

getIsArrayAttribute(

parser.getLine(), entry, "QUALIFIER.DECLARATION", isArray);

// Get ARRAYSIZE attribute:

Uint32 arraySize = 0;

Boolean gotArraySize = getArraySizeAttribute(parser.getLine(),

entry, "QUALIFIER.DECLARATION", arraySize);

// Get flavor oriented attributes:

Uint32 flavor = getFlavor(entry,parser.getLine(), "QUALIFIER.DECLARATION");

// No need to look for interior elements if empty tag:

Uint32 scope = CIMScope::NONE;

CIMValue value;

if (!empty)

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

isInstance = true;

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

{

// Get the option SCOPE element:

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",

scope = getOptionalScope(parser);

"Expected INSTANCEPATH or CLASSPATH element");

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

// Get VALUE or VALUE.ARRAY element:

}

if (getValueArrayElement(parser, type, value))

if (isInstance)

{

if (!isArray)

{

throw XmlSemanticError(parser.getLine(),

CIMInstance cimInstance;

"VALUE.ARRAY element encountered without "

"ISARRAY attribute");

}

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

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

{

throw XmlSemanticError(parser.getLine(),

MessageLoaderParms mlParms(

"VALUE.ARRAY size is not the same as "

"Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"ARRAYSIZE attribute");

"Expected INSTANCE element");

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

}

objectWithPath = CIMObject (cimInstance);

objectWithPath.setPath (reference);

}

else if (getValueElement(parser, type, value))

else

{

if (isArray)

CIMClass cimClass;

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

{

throw XmlSemanticError(parser.getLine(),

MessageLoaderParms mlParms(

"ISARRAY attribute used but VALUE element encountered");

"Common.XmlReader.EXPECTED_CLASS_ELEMENT",

"Expected CLASS element");

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

}

objectWithPath = CIMObject (cimClass);

objectWithPath.setPath (reference);

}

// Now get the closing tag:

expectEndTag(parser, "VALUE.OBJECTWITHPATH");

expectEndTag(parser, "QUALIFIER.DECLARATION");

}

if (value.getType() == CIMType::NONE)

{

if (isArray)

value.setNullValue(type, true, arraySize);

else

value.setNullValue(type, false);

}

CIMQualifierDecl tmp(name, value, scope, flavor, arraySize);

qualifierDecl = CIMQualifierDecl(name, value, scope, flavor, arraySize);

return true;

}

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

// getMethodElement()

// getValueObjectWithLocalPathElement()

// <!ELEMENT METHOD (QUALIFIER*,(PARAMETER|PARAMETER.REFERENCE|

// <!ELEMENT VALUE.OBJECTWITHLOCALPATH

// PARAMETER.ARRAY|PARAMETER.REFARRAY)*)>

// ((LOCALCLASSPATH,CLASS)|(LOCALINSTANCEPATH,INSTANCE))>

// <!ATTLIST METHOD

// %CIMName;

// %CIMType; #IMPLIED

// %ClassOrigin;

// %Propagated;>

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

Boolean XmlReader::getMethodElement(XmlParser& parser, CIMMethod& method)

Boolean XmlReader::getValueObjectWithLocalPathElement(

XmlParser& parser,

CIMObject& objectWithPath)

{

XmlEntry entry;

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

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

return false;

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

CIMObjectPath reference;

Boolean isInstance = false;

String name = getCimNameAttribute(parser.getLine(), entry, "PROPERTY");

CIMType type = getCimTypeAttribute(parser.getLine(), entry, "PROPERTY");

String classOrigin =

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

Boolean propagated = getCimBooleanAttribute(

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

method = CIMMethod(name, type, classOrigin, propagated);

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

isInstance = true;

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

{

MessageLoaderParms mlParms(

"Common.XmlConstants.MISSING_ELEMENT_LOCALPATH",

MISSING_ELEMENT_LOCALPATH);

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

}

if (!empty)

if (isInstance)

{

getQualifierElements(parser, method);

CIMInstance cimInstance;

GetParameterElements(parser, method);

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

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

"Expected INSTANCE element");

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

}

objectWithPath = CIMObject (cimInstance);

objectWithPath.setPath (reference);

}

else

{

CIMClass cimClass;

expectEndTag(parser, "METHOD");

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

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_CLASS_ELEMENT",

"Expected CLASS element");

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

}

objectWithPath = CIMObject (cimClass);

objectWithPath.setPath (reference);

}

expectEndTag(parser, "VALUE.OBJECTWITHLOCALPATH");

return true;

}

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

// getClassElement()

// getObjectArray()

// <!ELEMENT CLASS (QUALIFIER*,

// <object>

// (PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,METHOD*)>

// (VALUE.OBJECT|VALUE.OBJECTWITHLOCALPATH|VALUE.OBJECTWITHPATH)

// <!ATTLIST CLASS %CIMName; %SuperClass;>

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

Boolean XmlReader::getClassElement(XmlParser& parser, CIMClass& cimClass)

void XmlReader::getObjectArray(

XmlParser& parser,

Array<CIMObject>& objectArray)

{

XmlEntry entry;

CIMObject object;

CIMObject objectWithPath;

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

objectArray.clear();

return false;

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

String superClass = getSuperClassAttribute(parser.getLine(), entry,"CLASS");

if (getValueObjectElement(parser, object))

{

objectArray.append(object);

while (getValueObjectElement(parser, object))

objectArray.append(object);

}

else if (getValueObjectWithPathElement(parser, objectWithPath))

{

objectArray.append(objectWithPath);

while (getValueObjectWithPathElement(parser, objectWithPath))

objectArray.append(objectWithPath);

}

else if (getValueObjectWithLocalPathElement(parser, objectWithPath))

{

objectArray.append(objectWithPath);

while (getValueObjectWithLocalPathElement(parser, objectWithPath))

objectArray.append(objectWithPath);

}

cimClass = CIMClass(name, superClass);

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

// <objectName>: (CLASSNAME|INSTANCENAME)

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

// Get QUALIFIER elements:

// Returns true if ClassNameElement or false if InstanceNameElement

// Parse errors always throw exception

Boolean XmlReader::getObjectNameElement(

XmlParser& parser,

CIMObjectPath& objectName)

{

CIMName className;

getQualifierElements(parser, cimClass);

if (getClassNameElement(parser, className, false))

{

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

// Get PROPERTY elements:

// Return flag indicating this is ClassNameElement

return true;

}

GetPropertyElements(parser, cimClass);

if (!getInstanceNameElement(parser, objectName))

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_CLASSNAME_OR_INSTANCENAME_ELEMENT",

"Expected CLASSNAME or INSTANCENAME element");

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

}

// Get METHOD elements:

// Return flag indicating this is InstanceNameElement

return false;

}

CIMMethod method;

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

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

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

while (getMethodElement(parser, method))

Boolean XmlReader::getObjectPathElement(

cimClass.addMethod(method);

XmlParser& parser,

CIMObjectPath& objectPath)

{

XmlEntry entry;

// Get CLASS end tag:

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

return false;

expectEndTag(parser, "CLASS");

if (!getClassPathElement(parser, objectPath) &&

!getInstancePathElement(parser, objectPath))

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_INSTANCEPATH_OR_CLASSPATH_ELEMENT",

"expected INSTANCEPATH or CLASSPATH element");

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

}

expectEndTag(parser, "OBJECTPATH");

return true;

}

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

// getInstanceElement()

// <!ELEMENT INSTANCE (QUALIFIER*,

// getEMethodCallStartTag()

// (PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*) >

// <!ATTLIST INSTANCE

// %ClassName;>

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

Boolean XmlReader::getInstanceElement(

Boolean XmlReader::getEMethodCallStartTag(

XmlParser& parser,

CIMInstance& cimInstance)

const char*& name)

{

XmlEntry entry;

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

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

return false;

String className = getClassNameAttribute(

// Get EXPMETHODCALL.NAME attribute:

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

cimInstance = CIMInstance(className);

// Get QUALIFIER elements:

getQualifierElements(parser, cimInstance);

// Get PROPERTY elements:

GetPropertyElements(parser, cimInstance);

// Get INSTANCE end tag:

expectEndTag(parser, "INSTANCE");

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

{

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_EXPMETHODCALL_ATTRIBUTE",

"Missing EXPMETHODCALL.NAME attribute");

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

}

return true;

}

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

// getMessageStartTag()

// getEMethodResponseStartTag()

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

Boolean XmlReader::getMessageStartTag(

Boolean XmlReader::getEMethodResponseStartTag(

XmlParser& parser,

Uint32& id,

const char*& name,

const char*& protocolVersion)

Boolean& isEmptyTag)

{

XmlEntry entry;

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

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

return false;

// Get MESSAGE.ID:

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

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

// Get EXPMETHODRESPONSE.NAME attribute:

throw XmlValidationError(parser.getLine(),

"Bad or missing MESSAGE.ID attribute");

// Get MESSAGE.PROTOCOLVERSION:

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

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

throw XmlValidationError(parser.getLine(),

{

"Bad or missing MESSAGE.ID attribute");

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_EXPMETHODRESPONSE_ATTRIBUTE",

"Missing EXPMETHODRESPONSE.NAME attribute");

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

}

return true;

}

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

// getIMethodCallStartTag()

// getEParamValueTag()

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

Boolean XmlReader::getIMethodCallStartTag(

Boolean XmlReader::getEParamValueTag(

XmlParser& parser,

const char*& name)

{

XmlEntry entry;

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

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

return false;

// Get IMETHODCALL.NAME attribute:

// Get EXPPARAMVALUE.NAME attribute:

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

throw XmlValidationError(parser.getLine(),

{

"Missing IMETHODCALL.NAME attribute");

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_EXPPARAMVALUE_ATTRIBUTE",

"Missing EXPPARAMVALUE.NAME attribute");

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

}

return true;

}

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

// getIMethodResponseStartTag()

// getMethodCallStartTag()

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

Boolean XmlReader::getIMethodResponseStartTag(

Boolean XmlReader::getMethodCallStartTag(

XmlParser& parser,

const char*& name)

{

XmlEntry entry;

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

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

return false;

// Get IMETHODRESPONSE.NAME attribute:

// Get METHODCALL.NAME attribute:

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

throw XmlValidationError(parser.getLine(),

{

"Missing IMETHODRESPONSE.NAME attribute");

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_METHODCALL_ATTRIBUTE",

"Missing METHODCALL.NAME attribute");

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

}

return true;

}

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

// getIParamValueTag()

// getMethodResponseStartTag()

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

Boolean XmlReader::getIParamValueTag(

Boolean XmlReader::getMethodResponseStartTag(

XmlParser& parser,

const char*& name)

const char*& name,

Boolean& isEmptyTag)

{

XmlEntry entry;

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

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

return false;

// Get IPARAMVALUE.NAME attribute:

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

// Get METHODRESPONSE.NAME attribute:

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

throw XmlValidationError(parser.getLine(),

{

"Missing IPARAMVALUE.NAME attribute");

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_METHODRESPONSE_ATTRIBUTE",

"Missing METHODRESPONSE.NAME attribute");

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

}

return true;

}

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

// getBooleanValueElement()

// getParamValueElement()

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

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

// <!ATTLIST PARAMVALUE

// %CIMName;

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

Boolean XmlReader::getBooleanValueElement(

Boolean XmlReader::getParamValueElement(

XmlParser& parser,

Boolean& result,

CIMParamValue& paramValue)

Boolean required)

{

XmlEntry entry;

const char* name;

CIMType type=CIMTYPE_BOOLEAN;

CIMValue value;

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

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

return false;

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

// Get PARAMVALUE.NAME attribute:

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

{

if (required)

MessageLoaderParms mlParms(

"Common.XmlReader.MISSING_PARAMVALUE_ATTRIBUTE",

"Missing PARAMVALUE.NAME attribute");

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

}

// Get PROPERTY.EmbeddedObject

EmbeddedObjectAttributeType embeddedObject = getEmbeddedObjectAttribute(

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

// Get PARAMVALUE.PARAMTYPE attribute:

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

"PARAMVALUE", "PARAMTYPE", false);

if (empty)

{

throw XmlValidationError(parser.getLine(),

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

"Expected VALUE element");

}

else

{

// Parse VALUE.REFERENCE and VALUE.REFARRAY type

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

{

CIMObjectPath reference;

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

{

value.set(reference);

type = CIMTYPE_REFERENCE;

gotType = true;

}

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

{

type = CIMTYPE_REFERENCE;

gotType = true;

}

else

{

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

}

return false;

}

expectContentOrCData(parser, entry);

// Parse non-reference value

if ( type != CIMTYPE_REFERENCE )

{

CIMType effectiveType;

if (!gotType)

{

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

effectiveType = CIMTYPE_STRING;

}

else

{

effectiveType = type;

}

if (strcmp(entry.text, "TRUE") == 0)

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

result = true;

// then

else if (strcmp(entry.text, "FALSE") == 0)

// Convert the EmbeddedObject-encoded string into a CIMObject

result = false;

if (embeddedObject != NO_EMBEDDED_OBJECT)

{

// The EmbeddedObject attribute is only valid on Parameters

// of type string

// The type must have been specified.

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

{

if (embeddedObject == EMBEDDED_OBJECT_ATTR)

// Used below by getValueElement() or

// getValueArrayElement()

effectiveType = CIMTYPE_OBJECT;

else

effectiveType = CIMTYPE_INSTANCE;

}

else

throw XmlSemanticError(parser.getLine(),

{

"Bad value for VALUE element: must be \"TRUE\" or \"FALSE\"");

MessageLoaderParms mlParms(

"Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

"The EmbeddedObject attribute is only valid on "

"string types.");

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

}

expectEndTag(parser, "VALUE");

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;

}

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

// getErrorElement()

// getReturnValueElement()

// <!ELEMENT ERROR EMPTY>

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

// <!ATTLIST ERROR

// <!ATTLIST RETURNVALUE

// CODE CDATA #REQUIRED

// %EmbeddedObject; #IMPLIED

// DESCRIPTION CDATA #IMPLIED>

// %ParamType;>

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

Boolean XmlReader::getErrorElement(

Boolean XmlReader::getReturnValueElement(

XmlParser& parser,

CIMException::Code& code,

CIMValue& returnValue)

const char*& description,

Boolean required)

{

XmlEntry entry;

CIMType type;

CIMValue value;

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

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

{

if (required)

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

return false;

// Get PROPERTY.EmbeddedObject

EmbeddedObjectAttributeType embeddedObject = getEmbeddedObjectAttribute(

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

// Get RETURNVALUE.PARAMTYPE attribute:

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

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

"RETURNVALUE", "PARAMTYPE", false);

// Parse VALUE.REFERENCE type

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

{

CIMObjectPath reference;

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

{

returnValue.set(reference);

type = CIMTYPE_REFERENCE;

gotType = true;

}

else if (type == CIMTYPE_REFERENCE)

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_VALUE_REFERENCE_ELEMENT",

"expected VALUE.REFERENCE element");

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

}

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

// Parse non-reference return value

if ( type != CIMTYPE_REFERENCE )

{

if (!gotType)

{

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

type = CIMTYPE_STRING;

}

if (embeddedObject != NO_EMBEDDED_OBJECT)

{

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

{

if (embeddedObject == EMBEDDED_OBJECT_ATTR)

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

type = CIMTYPE_OBJECT;

else

type = CIMTYPE_INSTANCE;

}

else

{

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

{

MessageLoaderParms mlParms(

"Common.XmlReader.EXPECTED_VALUE_ELEMENT",

"expected VALUE element");

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

}

// Get ERROR.CODE

expectEndTag(parser, "RETURNVALUE");

Uint32 tmpCode;

return true;

}

if (!entry.getAttributeValue("CODE", tmpCode))

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

throw XmlValidationError(

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

// The following is a common set of version tests used by the different

// Pegasus Request and Response Decoders

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

// isSupportedCIMVersion()

// tests for valid CIMVersion number

// Reject cimVersion not in 2.[0-9]+

// CIMXML Secification, Version 2.2 Final, Sect 3.2.1.1

// The CIMVERSION attribute defines the version of the CIM Specification to

// which the XML Document conforms. It MUST be in the form of "M.N". Where

// M is the Major Version of the specification in numeric form and N is the

// minor version of the specification in numeric form. For example, "2.0",

// "2.1". Implementations must only validate the major version as all minor

// versions are backward compatible. Implementations may look at the minor

// version to determine additional capabilites.

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

Boolean XmlReader::isSupportedCIMVersion(

const char* cimVersion)

{

Boolean cimVersionAccepted = false;

//printf("testCIMVersion %s \n", cimVersion);

if ((cimVersion[0] == '2') &&

(cimVersion[1] == '.') &&

(cimVersion[2] != 0))

{

// Verify that all characters after the '.' are digits

Uint32 index = 2;

while (isdigit(cimVersion[index]))

{

index++;

}

if (cimVersion[index] == 0)

{

cimVersionAccepted = true;

}

return cimVersionAccepted;

}

code = CIMException::Code(tmpCode);

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

// isSupportedProtocolVersion()

// tests for valid ProtocolVersion number

// Reject ProtocolVersion not 1.[0-9]

// cimxml spec 2.2 Final Section 3261

// The PROTOCOLVERSION attribute defines the version of the CIM Operations to

// which this message conforms. It MUST be in the form of "M.N". Where M is

// the Major Version of the specification in numeric form and N is the minor

// version of the specification in numeric form. For example, "1.0", "1.1".

// Implementations must only validate the major version as all minor versions

// are backward compatible. Implementations may look at the minor version to

// determine additional capabilites.

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

Boolean XmlReader::isSupportedProtocolVersion(

const String& protocolVersion)

{

Boolean protocolVersionAccepted = false;

// Get ERROR.DESCRIPTION:

//cout << "testProtocolVersion " << protocolVersion << endl;

if ((protocolVersion.size() >= 3) &&

(protocolVersion[0] == '1') &&

(protocolVersion[1] == '.'))

{

// Verify that all characters after the '.' are digits

Uint32 index = 2;

while ((index < protocolVersion.size()) &&

(protocolVersion[index] >= '0') &&

(protocolVersion[index] <= '9'))

{

index++;

}

description = "";

if (index == protocolVersion.size())

entry.getAttributeValue("DESCRIPTION", description);

{

protocolVersionAccepted = true;

}

return protocolVersionAccepted;

}

if (!empty)

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

expectEndTag(parser, "ERROR");

// isSupportedDTDVersion()

// Tests for Valid dtdVersion number

// We accept DTD version 2.[0-9]+ (see Bugzilla 1556)//

// CIM/XML Specification, V 2.2 Final, Section 3.2.1.1

// The DTDVERSION attribute defines the version of the CIM XML Mapping to

// which the XML Document conforms. It MUST be in the form of "M.N". Where

// M is the Major Version of the specification in numeric form and N is the

// minor version of the specification in numeric form. For example, "2.0",

// "2.1". Implementations must only validate the major version as all minor

// versions are backward compatible. Implementations may look at the minor

// version to determine additional capabilites.

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

Boolean XmlReader::isSupportedDTDVersion(

const char* dtdVersion)

{

Boolean dtdVersionAccepted = false;

return true;

//printf("testDTDVersion %s \n", dtdVersion);

if ((dtdVersion[0] == '2') &&

(dtdVersion[1] == '.') &&

(dtdVersion[2] != 0))

{

// Verify that all characters after the '.' are digits

Uint32 index = 2;

while (isdigit(dtdVersion[index]))

{

index++;

}

if (dtdVersion[index] == 0)

{

dtdVersionAccepted = true;

}

return dtdVersionAccepted;

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.6
changed lines
	Added in v.1.150

No CVS admin address has been configured