cimmessageserializer.cpp

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

// _serializeCIMInitializeProviderAgentRequestMessage
//
void CIMMessageSerializer::_serializeCIMInitializeProviderAgentRequestMessage(
    Buffer& out,
    CIMInitializeProviderAgentRequestMessage* message)
{
    XmlWriter::appendValueElement(out, message->pegasusHome);

    // Use PGCONFARRAY element to encapsulate the config property elements
    XmlWriter::append(out, "<PGCONFARRAY>\n");
    for (Uint32 i=0; i < message->configProperties.size(); i++)
    {
        XmlWriter::appendValueElement(out, message->configProperties[i].first);
        XmlWriter::appendValueElement(out, message->configProperties[i].second);
    }
    XmlWriter::append(out, "</PGCONFARRAY>\n");

    XmlWriter::appendValueElement(out, message->bindVerbose);

    XmlWriter::appendValueElement(out, message->subscriptionInitComplete);
}

//
// _serializeCIMNotifyConfigChangeRequestMessage
//
void CIMMessageSerializer::_serializeCIMNotifyConfigChangeRequestMessage(
    Buffer& out,
    CIMNotifyConfigChangeRequestMessage* message)
{
    XmlWriter::appendValueElement(out, message->propertyName);
    XmlWriter::appendValueElement(out, message->newPropertyValue);
    XmlWriter::appendValueElement(out, message->currentValueModified);
}

//
// _serializeCIMSubscriptionInitCompleteRequestMessage
//
void CIMMessageSerializer::_serializeCIMSubscriptionInitCompleteRequestMessage(
    Buffer& out,
    CIMSubscriptionInitCompleteRequestMessage* message)
{
    // No additional attributes to serialize!
}

//
//
// Response Messages
//
//

//
//
// CIM Operation Response Messages
//
//

//
// _serializeCIMGetInstanceResponseMessage
//
void CIMMessageSerializer::_serializeCIMGetInstanceResponseMessage(
    Buffer& out,
    CIMGetInstanceResponseMessage* message)
{
    _serializeCIMInstance(out, message->cimInstance);
}

//
// _serializeCIMDeleteInstanceResponseMessage
//
void CIMMessageSerializer::_serializeCIMDeleteInstanceResponseMessage(
    Buffer& out,
    CIMDeleteInstanceResponseMessage* message)
{
    // No additional attributes to serialize!
}

//
// _serializeCIMCreateInstanceResponseMessage
//
void CIMMessageSerializer::_serializeCIMCreateInstanceResponseMessage(
    Buffer& out,
    CIMCreateInstanceResponseMessage* message)
{
    _serializeCIMObjectPath(out, message->instanceName);
}

//
// _serializeCIMModifyInstanceResponseMessage
//
void CIMMessageSerializer::_serializeCIMModifyInstanceResponseMessage(
    Buffer& out,
    CIMModifyInstanceResponseMessage* message)
{
    // No additional attributes to serialize!
}

//
// _serializeCIMEnumerateInstancesResponseMessage
//
void CIMMessageSerializer::_serializeCIMEnumerateInstancesResponseMessage(
    Buffer& out,
    CIMEnumerateInstancesResponseMessage* message)
{
    // Use PGINSTARRAY element to encapsulate the CIMInstance elements
    XmlWriter::append(out, "<PGINSTARRAY>\n");
    for (Uint32 i=0; i < message->cimNamedInstances.size(); i++)
    {
        _serializeCIMInstance(out, message->cimNamedInstances[i]);
    }
    XmlWriter::append(out, "</PGINSTARRAY>\n");
}

//
// _serializeCIMEnumerateInstanceNamesResponseMessage
//
void CIMMessageSerializer::_serializeCIMEnumerateInstanceNamesResponseMessage(
    Buffer& out,
    CIMEnumerateInstanceNamesResponseMessage* message)
{
    // Use PGPATHARRAY element to encapsulate the object path elements
    XmlWriter::append(out, "<PGPATHARRAY>\n");
    for (Uint32 i=0; i < message->instanceNames.size(); i++)
    {
        _serializeCIMObjectPath(out, message->instanceNames[i]);
    }
    XmlWriter::append(out, "</PGPATHARRAY>\n");
}

//
// _serializeCIMExecQueryResponseMessage
//
void CIMMessageSerializer::_serializeCIMExecQueryResponseMessage(
    Buffer& out,
    CIMExecQueryResponseMessage* message)
{
    // Use PGOBJARRAY element to encapsulate the CIMObject elements
    XmlWriter::append(out, "<PGOBJARRAY>\n");
    for (Uint32 i=0; i < message->cimObjects.size(); i++)
    {
        _serializeCIMObject(out, message->cimObjects[i]);
    }
    XmlWriter::append(out, "</PGOBJARRAY>\n");
}

//
// _serializeCIMAssociatorsResponseMessage
//
void CIMMessageSerializer::_serializeCIMAssociatorsResponseMessage(
    Buffer& out,
    CIMAssociatorsResponseMessage* message)
{
    // Use PGOBJARRAY element to encapsulate the CIMObject elements
    XmlWriter::append(out, "<PGOBJARRAY>\n");
    for (Uint32 i=0; i < message->cimObjects.size(); i++)
    {
        _serializeCIMObject(out, message->cimObjects[i]);
    }
    XmlWriter::append(out, "</PGOBJARRAY>\n");
}

//
// _serializeCIMAssociatorNamesResponseMessage
//
void CIMMessageSerializer::_serializeCIMAssociatorNamesResponseMessage(
    Buffer& out,
    CIMAssociatorNamesResponseMessage* message)
{
    // Use PGPATHARRAY element to encapsulate the object path elements
    XmlWriter::append(out, "<PGPATHARRAY>\n");
    for (Uint32 i=0; i < message->objectNames.size(); i++)
    {
        _serializeCIMObjectPath(out, message->objectNames[i]);
    }
    XmlWriter::append(out, "</PGPATHARRAY>\n");
}

//
// _serializeCIMReferencesResponseMessage
//
void CIMMessageSerializer::_serializeCIMReferencesResponseMessage(
    Buffer& out,
    CIMReferencesResponseMessage* message)
{
    // Use PGOBJARRAY element to encapsulate the CIMObject elements
    XmlWriter::append(out, "<PGOBJARRAY>\n");
    for (Uint32 i=0; i < message->cimObjects.size(); i++)
    {
        _serializeCIMObject(out, message->cimObjects[i]);
    }
    XmlWriter::append(out, "</PGOBJARRAY>\n");
}

//
// _serializeCIMReferenceNamesResponseMessage
//
void CIMMessageSerializer::_serializeCIMReferenceNamesResponseMessage(
    Buffer& out,
    CIMReferenceNamesResponseMessage* message)
{
    // Use PGPATHARRAY element to encapsulate the object path elements
    XmlWriter::append(out, "<PGPATHARRAY>\n");
    for (Uint32 i=0; i < message->objectNames.size(); i++)
    {
        _serializeCIMObjectPath(out, message->objectNames[i]);
    }
    XmlWriter::append(out, "</PGPATHARRAY>\n");
}

//
// _serializeCIMGetPropertyResponseMessage
//
void CIMMessageSerializer::_serializeCIMGetPropertyResponseMessage(
    Buffer& out,
    CIMGetPropertyResponseMessage* message)
{
    // Use PARAMVALUE element so we can preserve the CIMType information
    XmlWriter::appendParamValueElement(
        out,
        CIMParamValue(String("ignore"), message->value, true));
}

//
// _serializeCIMSetPropertyResponseMessage
//
void CIMMessageSerializer::_serializeCIMSetPropertyResponseMessage(
    Buffer& out,
    CIMSetPropertyResponseMessage* message)
{
    // No additional attributes to serialize!
}

//
// _serializeCIMInvokeMethodResponseMessage
//
void CIMMessageSerializer::_serializeCIMInvokeMethodResponseMessage(
    Buffer& out,
    CIMInvokeMethodResponseMessage* message)
{
    // Use PARAMVALUE element so we can preserve the CIMType information
    XmlWriter::appendParamValueElement(
        out,
        CIMParamValue(String("ignore"), message->retValue, true));

    // Use PGPARAMS element so we can find the end of the PARAMVALUE elements
    XmlWriter::append(out, "<PGPARAMS>\n");
    for (Uint32 i=0; i < message->outParameters.size(); i++)
    {
        XmlWriter::appendParamValueElement(out, message->outParameters[i]);
    }
    XmlWriter::append(out, "</PGPARAMS>\n");

    _serializeCIMName(out, message->methodName);
}


//
//
// CIM Indication Response Messages
//
//

//
// _serializeCIMCreateSubscriptionResponseMessage
//
void CIMMessageSerializer::_serializeCIMCreateSubscriptionResponseMessage(
    Buffer& out,
    CIMCreateSubscriptionResponseMessage* message)
{
    // No additional attributes to serialize!
}

//
// _serializeCIMModifySubscriptionResponseMessage
//
void CIMMessageSerializer::_serializeCIMModifySubscriptionResponseMessage(
    Buffer& out,
    CIMModifySubscriptionResponseMessage* message)
{
    // No additional attributes to serialize!
}

//
// _serializeCIMDeleteSubscriptionResponseMessage
//
void CIMMessageSerializer::_serializeCIMDeleteSubscriptionResponseMessage(
    Buffer& out,
    CIMDeleteSubscriptionResponseMessage* message)
{
    // No additional attributes to serialize!
}


//
//
// Other CIMResponseMessages
//
//

//
// _serializeCIMExportIndicationResponseMessage
//
void CIMMessageSerializer::_serializeCIMExportIndicationResponseMessage(
    Buffer& out,
    CIMExportIndicationResponseMessage* message)
{
    // No additional attributes to serialize!
}

//
// _serializeCIMProcessIndicationResponseMessage
//
void CIMMessageSerializer::_serializeCIMProcessIndicationResponseMessage(
    Buffer& out,
    CIMProcessIndicationResponseMessage* message)
{
    // No additional attributes to serialize!
}

//
// _serializeCIMDisableModuleResponseMessage
//
void CIMMessageSerializer::_serializeCIMDisableModuleResponseMessage(
    Buffer& out,
    CIMDisableModuleResponseMessage* message)
{
    // Use PGUINT16ARRAY element to encapsulate the Uint16 elements
    XmlWriter::append(out, "<PGUINT16ARRAY>\n");
    for (Uint32 i=0; i < message->operationalStatus.size(); i++)
    {
        XmlWriter::appendValueElement(out, message->operationalStatus[i]);
    }
    XmlWriter::append(out, "</PGUINT16ARRAY>\n");
}

//
// _serializeCIMEnableModuleResponseMessage
//
void CIMMessageSerializer::_serializeCIMEnableModuleResponseMessage(
    Buffer& out,
    CIMEnableModuleResponseMessage* message)
{
    // Use PGUINT16ARRAY element to encapsulate the Uint16 elements
    XmlWriter::append(out, "<PGUINT16ARRAY>\n");
    for (Uint32 i=0; i < message->operationalStatus.size(); i++)
    {
        XmlWriter::appendValueElement(out, message->operationalStatus[i]);
    }
    XmlWriter::append(out, "</PGUINT16ARRAY>\n");
}

//
// _serializeCIMStopAllProvidersResponseMessage
//
void CIMMessageSerializer::_serializeCIMStopAllProvidersResponseMessage(
    Buffer& out,
    CIMStopAllProvidersResponseMessage* message)
{
    // No additional attributes to serialize!
}

//
// _serializeCIMInitializeProviderResponseMessage
//
void CIMMessageSerializer::_serializeCIMInitializeProviderResponseMessage(
    Buffer& out,
    CIMInitializeProviderResponseMessage* message)
{
    // No additional attributes to serialize!
}

//
// _serializeCIMInitializeProviderAgentResponseMessage
//
void CIMMessageSerializer::_serializeCIMInitializeProviderAgentResponseMessage(
    Buffer& out,
    CIMInitializeProviderAgentResponseMessage* message)
{
    // No additional attributes to serialize!
}

//
// _serializeCIMNotifyConfigChangeResponseMessage
//
void CIMMessageSerializer::_serializeCIMNotifyConfigChangeResponseMessage(
    Buffer& out,
    CIMNotifyConfigChangeResponseMessage* message)
{
    // No additional attributes to serialize!
}

//
// _serializeCIMSubscriptionInitCompleteResponseMessage
//
void CIMMessageSerializer::_serializeCIMSubscriptionInitCompleteResponseMessage(
    Buffer& out,
    CIMSubscriptionInitCompleteResponseMessage* message)
{
    // No additional attributes to serialize!
}

PEGASUS_NAMESPACE_END