cimmessagedeserializer.cpp

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

            resultClass,
            role,
            includeQualifiers,
            includeClassOrigin,
            propertyList,
            QueueIdStack());

    return message;
}

//
// _deserializeCIMReferenceNamesRequestMessage
//
CIMReferenceNamesRequestMessage*
CIMMessageDeserializer::_deserializeCIMReferenceNamesRequestMessage(
    XmlParser& parser)
{
    CIMValue genericValue;
    CIMObjectPath objectName;
    CIMName resultClass;
    String role;

    _deserializeCIMObjectPath(parser, objectName);
    _deserializeCIMName(parser, resultClass);

    XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
    genericValue.get(role);

    CIMReferenceNamesRequestMessage* message =
        new CIMReferenceNamesRequestMessage(
            String::EMPTY,         // messageId
            CIMNamespaceName(),    // nameSpace
            objectName,
            resultClass,
            role,
            QueueIdStack());

    return message;
}

//
// _deserializeCIMGetPropertyRequestMessage
//
CIMGetPropertyRequestMessage*
CIMMessageDeserializer::_deserializeCIMGetPropertyRequestMessage(
    XmlParser& parser)
{
    CIMObjectPath instanceName;
    CIMName propertyName;

    _deserializeCIMObjectPath(parser, instanceName);
    _deserializeCIMName(parser, propertyName);

    CIMGetPropertyRequestMessage* message =
        new CIMGetPropertyRequestMessage(
            String::EMPTY,         // messageId
            CIMNamespaceName(),    // nameSpace
            instanceName,
            propertyName,
            QueueIdStack());

    return message;
}

//
// _deserializeCIMSetPropertyRequestMessage
//
CIMSetPropertyRequestMessage*
CIMMessageDeserializer::_deserializeCIMSetPropertyRequestMessage(
    XmlParser& parser)
{
    CIMObjectPath instanceName;
    CIMParamValue newValue;

    _deserializeCIMObjectPath(parser, instanceName);

    XmlReader::getParamValueElement(parser, newValue);

    CIMSetPropertyRequestMessage* message =
        new CIMSetPropertyRequestMessage(
            String::EMPTY,         // messageId
            CIMNamespaceName(),    // nameSpace
            instanceName,
            newValue.getParameterName(),
            newValue.getValue(),
            QueueIdStack());

    return message;
}

//
// _deserializeCIMInvokeMethodRequestMessage
//
CIMInvokeMethodRequestMessage*
CIMMessageDeserializer::_deserializeCIMInvokeMethodRequestMessage(
    XmlParser& parser)
{
    XmlEntry entry;
    CIMParamValue genericParamValue;
    CIMObjectPath instanceName;
    CIMName methodName;
    Array<CIMParamValue> inParameters;

    _deserializeCIMObjectPath(parser, instanceName);
    _deserializeCIMName(parser, methodName);

    // Get inParameter array
    XmlReader::expectStartTag(parser, entry, "PGPARAMS");
    while (XmlReader::getParamValueElement(parser, genericParamValue))
    {
        inParameters.append(genericParamValue);
    }
    XmlReader::expectEndTag(parser, "PGPARAMS");

    CIMInvokeMethodRequestMessage* message =
        new CIMInvokeMethodRequestMessage(
            String::EMPTY,         // messageId
            CIMNamespaceName(),    // nameSpace
            instanceName,
            methodName,
            inParameters,
            QueueIdStack());

    return message;
}


//
//
// CIMIndicationRequestMessages
//
//

//
// _deserializeCIMCreateSubscriptionRequestMessage
//
CIMCreateSubscriptionRequestMessage*
CIMMessageDeserializer::_deserializeCIMCreateSubscriptionRequestMessage(
    XmlParser& parser)
{
    XmlEntry entry;
    CIMValue genericValue;
    CIMName genericName;
    CIMNamespaceName nameSpace;
    CIMInstance subscriptionInstance;
    Array<CIMName> classNames;
    CIMPropertyList propertyList;
    Uint16 repeatNotificationPolicy;
    String query;

    _deserializeCIMNamespaceName(parser, nameSpace);
    _deserializeCIMInstance(parser, subscriptionInstance);

    // Get classNames array
    XmlReader::expectStartTag(parser, entry, "PGNAMEARRAY");
    while (_deserializeCIMName(parser, genericName))
    {
        classNames.append(genericName);
    }
    XmlReader::expectEndTag(parser, "PGNAMEARRAY");

    _deserializeCIMPropertyList(parser, propertyList);

    // Decode repeatNotificationPolicy
    XmlReader::getValueElement(parser, CIMTYPE_UINT16, genericValue);
    genericValue.get(repeatNotificationPolicy);

    XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
    genericValue.get(query);

    CIMCreateSubscriptionRequestMessage* message =
        new CIMCreateSubscriptionRequestMessage(
            String::EMPTY,         // messageId
            nameSpace,
            subscriptionInstance,
            classNames,
            propertyList,
            repeatNotificationPolicy,
            query,
            QueueIdStack());

    return message;
}

//
// _deserializeCIMModifySubscriptionRequestMessage
//
CIMModifySubscriptionRequestMessage*
CIMMessageDeserializer::_deserializeCIMModifySubscriptionRequestMessage(
    XmlParser& parser)
{
    XmlEntry entry;
    CIMValue genericValue;
    CIMName genericName;
    CIMNamespaceName nameSpace;
    CIMInstance subscriptionInstance;
    Array<CIMName> classNames;
    CIMPropertyList propertyList;
    Uint16 repeatNotificationPolicy;
    String query;

    _deserializeCIMNamespaceName(parser, nameSpace);
    _deserializeCIMInstance(parser, subscriptionInstance);

    // Get classNames array
    XmlReader::expectStartTag(parser, entry, "PGNAMEARRAY");
    while (_deserializeCIMName(parser, genericName))
    {
        classNames.append(genericName);
    }
    XmlReader::expectEndTag(parser, "PGNAMEARRAY");

    _deserializeCIMPropertyList(parser, propertyList);

    // Decode repeatNotificationPolicy
    XmlReader::getValueElement(parser, CIMTYPE_UINT16, genericValue);
    genericValue.get(repeatNotificationPolicy);

    XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
    genericValue.get(query);

    CIMModifySubscriptionRequestMessage* message =
        new CIMModifySubscriptionRequestMessage(
            String::EMPTY,         // messageId
            nameSpace,
            subscriptionInstance,
            classNames,
            propertyList,
            repeatNotificationPolicy,
            query,
            QueueIdStack());

    return message;
}

//
// _deserializeCIMDeleteSubscriptionRequestMessage
//
CIMDeleteSubscriptionRequestMessage*
CIMMessageDeserializer::_deserializeCIMDeleteSubscriptionRequestMessage(
    XmlParser& parser)
{
    XmlEntry entry;
    CIMName genericName;
    CIMNamespaceName nameSpace;
    CIMInstance subscriptionInstance;
    Array<CIMName> classNames;

    _deserializeCIMNamespaceName(parser, nameSpace);
    _deserializeCIMInstance(parser, subscriptionInstance);

    // Get classNames array
    XmlReader::expectStartTag(parser, entry, "PGNAMEARRAY");
    while (_deserializeCIMName(parser, genericName))
    {
        classNames.append(genericName);
    }
    XmlReader::expectEndTag(parser, "PGNAMEARRAY");

    CIMDeleteSubscriptionRequestMessage* message =
        new CIMDeleteSubscriptionRequestMessage(
            String::EMPTY,         // messageId
            nameSpace,
            subscriptionInstance,
            classNames,
            QueueIdStack());

    return message;
}


//
//
// Other CIMRequestMessages
//
//

//
// _deserializeCIMExportIndicationRequestMessage
//
CIMExportIndicationRequestMessage*
CIMMessageDeserializer::_deserializeCIMExportIndicationRequestMessage(
    XmlParser& parser)
{
    CIMValue genericValue;
    String authType;
    String userName;
    String destinationPath;
    CIMInstance indicationInstance;

    _deserializeUserInfo(parser, authType, userName);

    XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
    genericValue.get(destinationPath);

    _deserializeCIMInstance(parser, indicationInstance);

    CIMExportIndicationRequestMessage* message =
        new CIMExportIndicationRequestMessage(
            String::EMPTY,         // messageId
            destinationPath,
            indicationInstance,
            QueueIdStack(),        // queueIds
            authType,
            userName);

    return message;
}

//
// _deserializeCIMProcessIndicationRequestMessage
//
CIMProcessIndicationRequestMessage*
CIMMessageDeserializer::_deserializeCIMProcessIndicationRequestMessage(
    XmlParser& parser)
{
    XmlEntry entry;
    CIMObjectPath genericObjectPath;
    CIMNamespaceName nameSpace;
    CIMInstance indicationInstance;
    Array<CIMObjectPath> subscriptionInstanceNames;
    CIMInstance provider;

    _deserializeCIMNamespaceName(parser, nameSpace);
    _deserializeCIMInstance(parser, indicationInstance);

    // Get subscriptionInstanceNames array
    XmlReader::expectStartTag(parser, entry, "PGPATHARRAY");
    while (_deserializeCIMObjectPath(parser, genericObjectPath))
    {
        subscriptionInstanceNames.append(genericObjectPath);
    }
    XmlReader::expectEndTag(parser, "PGPATHARRAY");

    _deserializeCIMInstance(parser, provider);

    CIMProcessIndicationRequestMessage* message =
        new CIMProcessIndicationRequestMessage(
            String::EMPTY,         // messageId
            nameSpace,
            indicationInstance,
            subscriptionInstanceNames,
            provider,
            QueueIdStack());       // queueIds

    return message;
}

//
// _deserializeCIMDisableModuleRequestMessage
//
CIMDisableModuleRequestMessage*
CIMMessageDeserializer::_deserializeCIMDisableModuleRequestMessage(
    XmlParser& parser)
{
    XmlEntry entry;
    CIMValue genericValue;
    CIMInstance genericInstance;
    Boolean genericBoolean;
    String authType;
    String userName;
    CIMInstance providerModule;
    Array<CIMInstance> providers;
    Boolean disableProviderOnly;
    Array<Boolean> indicationProviders;

    _deserializeUserInfo(parser, authType, userName);

    _deserializeCIMInstance(parser, providerModule);

    // Get providers array
    XmlReader::expectStartTag(parser, entry, "PGINSTARRAY");
    while (_deserializeCIMInstance(parser, genericInstance))
    {
        providers.append(genericInstance);
    }
    XmlReader::expectEndTag(parser, "PGINSTARRAY");

    XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
    genericValue.get(disableProviderOnly);

    // Get indicationProviders array
    XmlReader::expectStartTag(parser, entry, "PGBOOLARRAY");
    while (XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue))
    {
        genericValue.get(genericBoolean);
        indicationProviders.append(genericBoolean);
    }
    XmlReader::expectEndTag(parser, "PGBOOLARRAY");

    CIMDisableModuleRequestMessage* message =
        new CIMDisableModuleRequestMessage(
            String::EMPTY,         // messageId
            providerModule,
            providers,
            disableProviderOnly,
            indicationProviders,
            QueueIdStack(),        // queueIds
            authType,
            userName);

    return message;
}

//
// _deserializeCIMEnableModuleRequestMessage
//
CIMEnableModuleRequestMessage*
CIMMessageDeserializer::_deserializeCIMEnableModuleRequestMessage(
    XmlParser& parser)
{
    String authType;
    String userName;
    CIMInstance providerModule;

    _deserializeUserInfo(parser, authType, userName);

    _deserializeCIMInstance(parser, providerModule);

    CIMEnableModuleRequestMessage* message =
        new CIMEnableModuleRequestMessage(
            String::EMPTY,         // messageId
            providerModule,
            QueueIdStack(),        // queueIds
            authType,
            userName);

    return message;
}

//
// _deserializeCIMStopAllProvidersRequestMessage
//
CIMStopAllProvidersRequestMessage*
CIMMessageDeserializer::_deserializeCIMStopAllProvidersRequestMessage(
    XmlParser& parser)
{