xmlreader.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

    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:

    String 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(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
        {
            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
        {
            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");
    }

    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 (!stringToUnsignedInteger(tmp, arraySize) || arraySize == 0)
    {
        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",
        fa