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.104 and 1.118.6.1

version 1.104, 2004/09/22 18:59:41

version 1.118.6.1, 2006/07/30 19:26:30

Line 1

//%2003////////////////////////////////////////////////////////////////////////

//%2006////////////////////////////////////////////////////////////////////////

// Company, L. P., IBM Corp., The Open Group, Tivoli Systems.

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// IBM Corp.; EMC Corporation, The Open Group.

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; Symantec Corporation; The Open Group.

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

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

Line 29

Line 35

// (carolann_graves@hp.com)

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

// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

// Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)

// Josephine Eskaline Joyce, IBM (jojustin@in.ibm.com) for Bug#3103

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

#include <Pegasus/Common/Config.h>

#include <cctype>

#include <cstdio>

#include <cstdlib>

#if defined(PEGASUS_OS_TYPE_UNIX)

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

#include <errno.h>

#endif

#include "CIMName.h"

Line 50

Line 58

#include "System.h"

#include "XmlConstants.h"

#ifdef PEGASUS_PLATFORM_OS400_ISERIES_IBM

#include "OS400ConvertChar.h"

#include "EBCDIC_OS400.h"

#endif

// l10n

#include <Pegasus/Common/MessageLoader.h>

#include <Pegasus/Common/AutoPtr.h>

#include "CIMNameUnchecked.h"

#define PEGASUS_SINT64_MIN (PEGASUS_SINT64_LITERAL(0x8000000000000000))

#define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(0xFFFFFFFFFFFFFFFF)

Line 470

Line 480

#endif

}

return CIMName (name);

return CIMNameUnchecked(name);

}

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

Line 574

Line 584

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

// getEmbeddedObjectAttribute()

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

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

String XmlReader::getEmbeddedObjectAttribute(

Uint32 lineNumber,

const XmlEntry& entry,

const char* elementName)

{

String embeddedObject;

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

return String();

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

// value "object" or "instance".

if (!(String::equal(embeddedObject, "object") ||

String::equal(embeddedObject, "instance")

)

{

// l10n

// char buffer[MESSAGE_SIZE];

// sprintf(buffer,

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

// throw XmlSemanticError(lineNumber, buffer);

char buffer[MESSAGE_SIZE];

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

MessageLoaderParms mlParms("Common.XmlReader.ILLEGAL_VALUE_FOR_ATTRIBUTE",

"Illegal value for $0 attribute",

buffer);

throw XmlSemanticError(lineNumber, mlParms);

}

return embeddedObject;

}

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

// getReferenceClassAttribute()

// <!ENTITY % ReferenceClass "REFERENCECLASS CDATA #IMPLIED">

Line 746

Line 802

type = CIMTYPE_REAL64;

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

type = CIMTYPE_REFERENCE;

// PEP 194:

// Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, just a

// Pegasus internal representation of an embedded object, so it won't be found here.

else unrecognizedType = true;

if (unrecognizedType ||

Line 1527

Line 1586

return CIMValue(x);

}

// PEP 194:

// Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, but just a

// Pegasus internal representation of an embedded object. However, this case is

// used when decoding string representations of embedded objects.

case CIMTYPE_OBJECT:

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

{

CIMObject x;

if (*valueString == '\0')

{

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[strlen(valueString) + 1]);

strcpy(tmp_buffer.get(), valueString);

XmlParser tmp_parser(tmp_buffer.get());

// The next bit of logic constructs a CIMObject from the Embedded Object String.

// It is similar to the method XmlReader::getValueObjectElement().

CIMInstance cimInstance;

CIMClass cimClass;

if (XmlReader::getInstanceElement(tmp_parser, cimInstance))

{

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

if(type == CIMTYPE_INSTANCE)

return CIMValue(cimInstance);

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

x = CIMObject(cimInstance);

}

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

{

x = CIMObject(cimClass);

}

else

{

// l10n

// throw XmlValidationError(parser.getLine(),

// "Expected INSTANCE or CLASS element");

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

if(type == CIMTYPE_OBJECT)

{

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",

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

throw XmlValidationError(lineNumber, mlParms);

}

else

{

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_ELEMENT",

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

throw XmlValidationError(lineNumber, mlParms);

}

#else

MessageLoaderParms mlParms("Common.XmlReader.EXPECTED_INSTANCE_OR_CLASS_ELEMENT",

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

throw XmlValidationError(lineNumber, mlParms);

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

}

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

tmp_buffer.reset();

}

return CIMValue(x);

}

default:

break;

}

Line 1592

Line 1726

XmlEntry entry;

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

{

return false;

}

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

Line 1601

Line 1737

if (!empty)

{

if (testContentOrCData(parser, entry))

{

valueString = entry.text;

}

expectEndTag(parser, "VALUE");

}

Line 1799

Line 1937

case CIMTYPE_REAL64:

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

// PEP 194:

// Note that "object" (ie. CIMTYPE_OBJECT) is not a real CIM datatype, but just a

// Pegasus internal representation of an embedded object. However, this case is

// used when decoding string representations of embedded objects.

case CIMTYPE_OBJECT:

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

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

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

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

default:

break;

}

Line 2099

Line 2248

// %CIMName;

// %ClassOrigin;

// %Propagated;

// %EmbeddedObject; #IMPLIED

// %CIMType; #REQUIRED>

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

Line 2126

Line 2276

Boolean propagated = getCimBooleanAttribute(

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

// Get PROPERTY.EMBEDDEDOBJECT attribute:

String embeddedObject = getEmbeddedObjectAttribute(

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

// Get PROPERTY.TYPE attribute:

CIMType type;

Line 2138

Line 2293

if (!empty)

{

// Get qualifiers:

// Get qualifiers. We need to do this before checking for the property as an

// embedded object, because we need to also check for the EmbeddedObject qualifier.

getQualifierElements(parser, property);

}

// Get value: Insert value if getValueElement exists (returns True)

Boolean embeddedObjectQualifierValue = false;

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

if (ix != PEG_NOT_FOUND)

{

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

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

String embeddedInstanceQualifierValue;

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

if (ix != PEG_NOT_FOUND)

{

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

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

// or the EmbeddedObject qualifier exists on this property with value "true"

// then

// Convert the EmbeddedObject-encoded string into a CIMObject

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

embeddedObjectQualifierValue;

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

embeddedInstanceQualifierValue.size() > 0;

if (isEmbeddedObject || isEmbeddedInstance)

{

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

if (type == CIMTYPE_STRING)

{

if(isEmbeddedObject)

type = CIMTYPE_OBJECT;

else

type = CIMTYPE_INSTANCE;

CIMValue new_value(type, false);

CIMProperty new_property = CIMProperty(name, new_value, 0, CIMName(), classOrigin, propagated);

// Copy the qualifiers from the String property to the CIMObject property.

for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)

{

// All properties are copied, including the EmbeddedObject qualifier.

// This way we don't have to keep track to know that the EmbeddedObject

// qualifier needs to be added back during the encode step.

new_property.addQualifier(property.getQualifier(ix));

}

value = new_value;

property = new_property;

}

else

{

// Error -- throw exception

// (the EmbeddedObject attribute may be applied only to entities that have the type String)

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected string type");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

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

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

}

#else

if (String::equal(embeddedObject, "object") || embeddedObjectQualifierValue)

{

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

if (type == CIMTYPE_STRING)

{

type = CIMTYPE_OBJECT;

CIMValue new_value(type, false);

CIMProperty new_property = CIMProperty(name, new_value, 0, CIMName(), classOrigin, propagated);

// Copy the qualifiers from the String property to the CIMObject property.

for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)

{

// All properties are copied, including the EmbeddedObject qualifier.

// This way we don't have to keep track to know that the EmbeddedObject

// qualifier needs to be added back during the encode step.

new_property.addQualifier(property.getQualifier(ix));

}

value = new_value;

property = new_property;

}

else

{

// Error -- throw exception

// (the EmbeddedObject attribute may be applied only to entities that have the type String)

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected string type");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

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

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

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

if (!empty)

{

if (getValueElement(parser, type, value))

property.setValue(value);

expectEndTag(parser, "PROPERTY");

}

Line 2209

Line 2467

// %CIMType; #REQUIRED

// %ArraySize;

// %ClassOrigin;

// %Propagated;>

// %Propagated;

// %EmbeddedObject; #IMPLIED>

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

Line 2243

Line 2502

// Get PROPERTY.CLASSORIGIN attribute:

CIMName classOrigin

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

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

// Get PROPERTY.ARRAY.PROPAGATED

Boolean propagated = getCimBooleanAttribute(

Boolean propagated = getCimBooleanAttribute(parser.getLine()

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

,entry

,"PROPERTY.ARRAY"

,"PROPAGATED"

,false

,false);

// Get PROPERTY.EMBEDDEDOBJECT attribute:

String embeddedObject = getEmbeddedObjectAttribute(parser.getLine()

,entry

,"PROPERTY.ARRAY");

// Create property:

CIMValue value(type, true, arraySize);

property = CIMProperty(

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

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

if (!empty)

{

// Get qualifiers:

getQualifierElements(parser, property);

}

Boolean embeddedObjectQualifierValue = false;

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

if (ix != PEG_NOT_FOUND)

{

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

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

String embeddedInstanceQualifierValue;

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

if (ix != PEG_NOT_FOUND)

{

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

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

// or the EmbeddedObject qualifier exists on this property with value "true"

// then

// Convert the EmbeddedObject-encoded string into a CIMObject

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

embeddedObjectQualifierValue;

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

embeddedInstanceQualifierValue.size() > 0;

if (isEmbeddedObject || isEmbeddedInstance)

{

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

if (type == CIMTYPE_STRING)

{

if(isEmbeddedObject)

type = CIMTYPE_OBJECT;

else

type = CIMTYPE_INSTANCE;

CIMValue new_value(type, true, arraySize);

CIMProperty new_property = CIMProperty(name, new_value, arraySize, CIMName(), classOrigin, propagated);

// Copy the qualifiers from the String property to the CIMObject property.

for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)

{

// All properties are copied, including the EmbeddedObject qualifier.

// This way we don't have to keep track to know that the EmbeddedObject

// qualifier needs to be added back during the encode step.

new_property.addQualifier(property.getQualifier(ix));

}

value = new_value;

property = new_property;

}

else

{

// Error -- throw exception

// (the EmbeddedObject attribute may be applied only to entities that have the type String)

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected string type");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

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

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

}

#else

if (String::equal(embeddedObject, "object") || embeddedObjectQualifierValue)

{

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

if (type == CIMTYPE_STRING)

{

type = CIMTYPE_OBJECT;

CIMValue new_value(type, true, arraySize);

CIMProperty new_property = CIMProperty(name, new_value, arraySize, CIMName(), classOrigin, propagated);

// Copy the qualifiers from the String property to the CIMObject property.

for (Uint32 ix = 0; ix < property.getQualifierCount(); ++ix)

{

// All properties are copied, including the EmbeddedObject qualifier.

// This way we don't have to keep track to know that the EmbeddedObject

// qualifier needs to be added back during the encode step.

new_property.addQualifier(property.getQualifier(ix));

}

// Get value:

value = new_value;

property = new_property;

}

else

{

// Error -- throw exception

// (the EmbeddedObject attribute may be applied only to entities that have the type String)

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected string type");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

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

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

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

// Else not an embedded object, if not empty, get the property array value.

if (!empty)

{

if (getValueArrayElement(parser, type, value))

{

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

Line 2283

Line 2654

property.setValue(value);

}

expectEndTag(parser, "PROPERTY.ARRAY");

}

Line 4417

Line 4787

}

return false;

PEGASUS_UNREACHABLE( return false; )

}

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

Line 4647

Line 5017

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

// <!ATTLIST PARAMVALUE

// %CIMName;

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

Line 4680

Line 5051

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

}

// Get PROPERTY.EMBEDDEDOBJECT

String embeddedObject = getEmbeddedObjectAttribute(

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

// Get PARAMVALUE.PARAMTYPE attribute:

Boolean gotType = getCimTypeAttribute(parser.getLine(), entry, type,

"PARAMVALUE", "PARAMTYPE", false);

if (!empty)

if (empty)

{

gotType = false; // Can't distinguish array and non-array types

}

else

{

// Parse VALUE.REFERENCE and VALUE.REFARRAY type

if ( (type == CIMTYPE_REFERENCE) || !gotType )

Line 4720

Line 5099

effectiveType = type;

}

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

// then

// Convert the EmbeddedObject-encoded string into a CIMObject

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

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

if(isEmbeddedObject || isEmbeddedInstance)

{

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

// The type must have been specified.

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

{

if(isEmbeddedObject)

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

else

effectiveType = CIMTYPE_INSTANCE;

}

else

{

// Error -- throw exception

// (the EmbeddedObject attribute may be applied only to entities that have the type String)

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected string type");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

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

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

}

#else

if (String::equal(embeddedObject, "object"))

{

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

// The type must have been specified.

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

{

// Used below by getValueElement() or getValueArrayElement()

effectiveType = CIMTYPE_OBJECT;

}

else

{

// Error -- throw exception

// (the EmbeddedObject attribute may be applied only to entities that have the type String)

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected string type");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

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

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

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

if ( !XmlReader::getValueArrayElement(parser, effectiveType, value) &&

!XmlReader::getValueElement(parser, effectiveType, value) )

{

gotType = false; // Can't distinguish array and non-array types

value.clear(); // Isn't necessary; should already be cleared

}

expectEndTag(parser, "PARAMVALUE");

}

paramValue = CIMParamValue(name, value, gotType);

return true;

Line 4741

Line 5184

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

// <!ATTLIST RETURNVALUE

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

Line 4756

Line 5200

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

return false;

// Get PROPERTY.EMBEDDEDOBJECT

String embeddedObject = getEmbeddedObjectAttribute(

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

// Get RETURNVALUE.PARAMTYPE attribute:

// NOTE: Array type return values are not allowed (2/20/02)

Line 4795

Line 5244

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

type = CIMTYPE_STRING;

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

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

if(isEmbeddedObject || isEmbeddedInstance)

{

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

{

if(isEmbeddedObject)

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

else

type = CIMTYPE_INSTANCE;

}

else

{

// Error -- throw exception

// (the EmbeddedObject attribute may be applied only to entities that have the type String)

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected string type");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

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

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

}

#else

if (String::equal(embeddedObject, "object"))

{

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

{

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

}

else

{

// Error -- throw exception

// (the EmbeddedObject attribute may be applied only to entities that have the type String)

// l10n

// throw XmlValidationError(parser.getLine(),

// "expected string type");

MessageLoaderParms mlParms("Common.XmlReader.INVALID_EMBEDDEDOBJECT_TYPE",

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

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

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

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

{

Legend:

Removed from v.1.104
changed lines
	Added in v.1.118.6.1

No CVS admin address has been configured