Return to CIMMessage.h CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

PEP#: 072
TITLE: [HP-RK] Out-of-Process Provider Support

DESCRIPTION: Remove CIMRepository dependency from the CMPI and JMPI Provider Managers.  (The Provider Managers will be used in Provider Agent processes, which do not have access to the repository.)  The repository had been required only to retrieve the query string from the CIM_IndicationFilter instance on a CreateSubscription operation.  The query string has been added to the CIMCreateSubscriptionRequestMessage and CIMModifySubscriptionRequestMessage classes to meet this need.

//%2003////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development
// Company, L. P., IBM Corp., The Open Group, Tivoli Systems.
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
// IBM Corp.; EMC 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
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, 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 ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 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.
//
//==============================================================================

//
// Author: Mike Brasher (mbrasher@bmc.com)
//
// Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
//              Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
//              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
//              Carol Ann Krug Graves, Hewlett-Packard Company
//                  (carolann_graves@hp.com)
//              Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)
//              Sushma Fernandes, Hewlett-Packard Company
//                  (sushma_fernandes@hp.com)
//              Chip Vincent (cvincent@us.ibm.com)
//              Jair Santos, Hewlett-Packard Company (jair.santos@hp.com)
//              Adrian Schuur (schuur@de.ibm.com)
//				Seema Gupta (gseema@in.ibm.com for PEP135
//
//%/////////////////////////////////////////////////////////////////////////////

#ifndef Pegasus_CIMMessage_h
#define Pegasus_CIMMessage_h

#include <Pegasus/Common/Config.h>
#include <Pegasus/Common/Message.h>
#include <Pegasus/Common/CIMParamValue.h>
#include <Pegasus/Common/CIMClass.h>
#include <Pegasus/Common/CIMInstance.h>
#include <Pegasus/Common/CIMQualifierDecl.h>
#include <Pegasus/Common/CIMObject.h>
#include <Pegasus/Common/CIMObjectPath.h>
#include <Pegasus/Common/CIMPropertyList.h>
#include <Pegasus/Common/XmlWriter.h>
#include <Pegasus/Common/Linkage.h>
#include <Pegasus/Common/OperationContext.h>
#include <Pegasus/Common/AcceptLanguages.h>  // l10n
#include <Pegasus/Common/ContentLanguages.h>  // l10n

/*   ProviderType should become part of Pegasus/Common     PEP# 99
   #include <Pegasus/ProviderManager2/ProviderType.h>
   #define TYPE_INSTANCE    ProviderType::INSTANCE
   #define TYPE_CLASS       ProviderType::CLASS
   #define TYPE_METHOD      ProviderType::METHOD
   #define TYPE_ASSOCIATION ProviderType::ASSOCIATION
   #define TYPE_QUERY       ProviderType::QUERY
*/ 
// using these equations instead      PEP# 99
   #define TYPE_CLASS       1
   #define TYPE_INSTANCE    2
   #define TYPE_ASSOCIATION 3
   #define TYPE_METHOD      5
   #define TYPE_QUERY       7


PEGASUS_NAMESPACE_BEGIN
PEGASUS_USING_STD;

// l10n - added AcceptLanguages and ContentLanguages below

class PEGASUS_COMMON_LINKAGE CIMMessage : public Message
{
public:

    CIMMessage(Uint32 type,
	 const String& messageId_,
	 const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	 const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
	: Message(type),
	 messageId(messageId_),
	 contentLanguages(contentLanguages_),
	 acceptLanguages(acceptLanguages_)
    {
    }

    virtual void print(PEGASUS_STD(ostream)& os, Boolean printHeader) const
    {
	if (printHeader)
	{
	    os << "CIMMessage\n";
	    os << "{";
	}

	Message::print(os, false);

	os << "    messageId=" << messageId << endl;

	if (printHeader)
	{
	    os << "}";
	}
    }

    String messageId;
    ContentLanguages contentLanguages;
    AcceptLanguages acceptLanguages;
	OperationContext operationContext;
};

class PEGASUS_COMMON_LINKAGE CIMRequestMessage : public CIMMessage
{
public:
    CIMRequestMessage(
        Uint32 type_,
	const String& messageId_,
	QueueIdStack queueIds_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMMessage(type_, messageId_, contentLanguages_, acceptLanguages_),
	queueIds(queueIds_)
    {
    }

    virtual void print(PEGASUS_STD(ostream)& os, Boolean printHeader) const
    {
	if (printHeader)
	{
	    os << "CIMRequestMessage\n";
	    os << "{";
	}

	CIMMessage::print(os, false);

	os << "    queueIds=" << "<not shown for now>" << endl;

	if (printHeader)
	{
	    os << "}";
	}
    }

    QueueIdStack queueIds;
    //OperationContext operationContext;
};

class PEGASUS_COMMON_LINKAGE CIMResponseMessage : public CIMMessage
{
public:
    CIMResponseMessage(
        Uint32 type_,
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMMessage(type_, messageId_, contentLanguages_, acceptLanguages_),
        queueIds(queueIds_),
        cimException(cimException_)
    {
    }

    QueueIdStack queueIds;
    CIMException cimException;
};

class PEGASUS_COMMON_LINKAGE CIMOperationRequestMessage : public CIMRequestMessage
{	// PEP# 99
public:
    CIMOperationRequestMessage(
        Uint32 type_,
	const String& messageId_,
	QueueIdStack queueIds_,
        const CIMNamespaceName& nameSpace_,
	const CIMName& className_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY,
	Uint32 providerType_ = TYPE_INSTANCE)
    : CIMRequestMessage(type_, messageId_, queueIds_,
	 contentLanguages_, acceptLanguages_),
        nameSpace(nameSpace_),
        className(className_),
        providerType(providerType_)
    {
    }
    CIMNamespaceName nameSpace;
    CIMName className;
    Uint32 providerType;
};

class PEGASUS_COMMON_LINKAGE CIMIndicationRequestMessage : public CIMRequestMessage
{	// PEP# 99
public:
    CIMIndicationRequestMessage(
        Uint32 type_,
        const String & messageId_,
        QueueIdStack queueIds_,
        const CIMInstance & provider_,
        const CIMInstance & providerModule_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMRequestMessage(type_, messageId_, queueIds_,
	 contentLanguages_, acceptLanguages_),
        provider(provider_),
        providerModule(providerModule_)
    {
    }
    CIMInstance provider;
    CIMInstance providerModule;
};

class PEGASUS_COMMON_LINKAGE CIMGetClassRequestMessage
    : public CIMOperationRequestMessage
{
public:
    CIMGetClassRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMName& className_,
        Boolean localOnly_,
        Boolean includeQualifiers_,
        Boolean includeClassOrigin_,
        const CIMPropertyList& propertyList_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(CIM_GET_CLASS_REQUEST_MESSAGE, messageId_, queueIds_,
         nameSpace_,className_,
	 contentLanguages_, acceptLanguages_,
	 TYPE_CLASS),
        localOnly(localOnly_),
        includeQualifiers(includeQualifiers_),
        includeClassOrigin(includeClassOrigin_),
        propertyList(propertyList_),
        authType(authType_),
        userName(userName_)
    {
    }

    Boolean localOnly;
    Boolean includeQualifiers;
    Boolean includeClassOrigin;
    CIMPropertyList propertyList;
    String authType;
    String userName;
};

class CIMGetInstanceRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMGetInstanceRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMObjectPath& instanceName_,
        Boolean localOnly_,
        Boolean includeQualifiers_,
        Boolean includeClassOrigin_,
        const CIMPropertyList& propertyList_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_GET_INSTANCE_REQUEST_MESSAGE, messageId_, queueIds_,
         nameSpace_,instanceName_.getClassName(),
	 contentLanguages_, acceptLanguages_),
	instanceName(instanceName_),
        localOnly(localOnly_),
        includeQualifiers(includeQualifiers_),
        includeClassOrigin(includeClassOrigin_),
        propertyList(propertyList_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMObjectPath instanceName;
    Boolean localOnly;
    Boolean includeQualifiers;
    Boolean includeClassOrigin;
    CIMPropertyList propertyList;
    String authType;
    String userName;
};

class CIMExportIndicationRequestMessage : public CIMRequestMessage
{
public:
    CIMExportIndicationRequestMessage(
        const String& messageId_,
        const String& destinationPath_,
        const CIMInstance& indicationInstance_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMRequestMessage(
        CIM_EXPORT_INDICATION_REQUEST_MESSAGE, messageId_, queueIds_,
	 contentLanguages_, acceptLanguages_),
        destinationPath(destinationPath_),
        indicationInstance(indicationInstance_),
        authType(authType_),
        userName(userName_)
    {
    }

    String destinationPath;
    CIMInstance indicationInstance;
    String authType;
    String userName;
};

class CIMDeleteClassRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMDeleteClassRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMName& className_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_DELETE_CLASS_REQUEST_MESSAGE, messageId_, queueIds_,
         nameSpace_,className_,
	 contentLanguages_, acceptLanguages_,
	 TYPE_CLASS),
        authType(authType_),
        userName(userName_)
    {
    }

    String authType;
    String userName;
};

class CIMDeleteInstanceRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMDeleteInstanceRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMObjectPath& instanceName_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_DELETE_INSTANCE_REQUEST_MESSAGE, messageId_, queueIds_,
         nameSpace_,instanceName_.getClassName(),
	 contentLanguages_, acceptLanguages_),
        instanceName(instanceName_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMObjectPath instanceName;
    String authType;
    String userName;
};

class CIMCreateClassRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMCreateClassRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMClass& newClass_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_CREATE_CLASS_REQUEST_MESSAGE, messageId_, queueIds_,
	 nameSpace_,newClass_.getClassName(),
	 contentLanguages_, acceptLanguages_,
	 TYPE_CLASS),
        newClass(newClass_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMClass newClass;
    String authType;
    String userName;
};

class CIMCreateInstanceRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMCreateInstanceRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMInstance& newInstance_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_CREATE_INSTANCE_REQUEST_MESSAGE, messageId_, queueIds_,
	 nameSpace_,newInstance_.getClassName(),
	 contentLanguages_, acceptLanguages_),
        newInstance(newInstance_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMInstance newInstance;
    String authType;
    String userName;
};

class CIMModifyClassRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMModifyClassRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMClass& modifiedClass_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_MODIFY_CLASS_REQUEST_MESSAGE, messageId_, queueIds_,
         nameSpace_,modifiedClass_.getClassName(),
	 contentLanguages_, acceptLanguages_,
	 TYPE_CLASS),
        modifiedClass(modifiedClass_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMClass modifiedClass;
    String authType;
    String userName;
};

class CIMModifyInstanceRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMModifyInstanceRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMInstance& modifiedInstance_,
        Boolean includeQualifiers_,
        const CIMPropertyList& propertyList_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_MODIFY_INSTANCE_REQUEST_MESSAGE, messageId_, queueIds_,
         nameSpace_,modifiedInstance_.getClassName(),
	 contentLanguages_, acceptLanguages_),
        modifiedInstance(modifiedInstance_),
        includeQualifiers(includeQualifiers_),
        propertyList(propertyList_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMInstance modifiedInstance;
    Boolean includeQualifiers;
    CIMPropertyList propertyList;
    String authType;
    String userName;
};

class CIMEnumerateClassesRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMEnumerateClassesRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMName& className_,
        Boolean deepInheritance_,
        Boolean localOnly_,
        Boolean includeQualifiers_,
        Boolean includeClassOrigin_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE, messageId_, queueIds_,
	 nameSpace_,className_,
	 contentLanguages_, acceptLanguages_,
	 TYPE_CLASS),
        deepInheritance(deepInheritance_),
        localOnly(localOnly_),
        includeQualifiers(includeQualifiers_),
        includeClassOrigin(includeClassOrigin_),
        authType(authType_),
        userName(userName_)
    {
    }

    Boolean deepInheritance;
    Boolean localOnly;
    Boolean includeQualifiers;
    Boolean includeClassOrigin;
    String authType;
    String userName;
};

class CIMEnumerateClassNamesRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMEnumerateClassNamesRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMName& className_,
        Boolean deepInheritance_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE, messageId_, queueIds_,
	 nameSpace_,className_,
	 contentLanguages_, acceptLanguages_,
	 TYPE_CLASS),
        deepInheritance(deepInheritance_),
        authType(authType_),
        userName(userName_)
    {
    }

    Boolean deepInheritance;
    String authType;
    String userName;
};

class CIMEnumerateInstancesRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMEnumerateInstancesRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMName& className_,
        Boolean deepInheritance_,
        Boolean localOnly_,
        Boolean includeQualifiers_,
        Boolean includeClassOrigin_,
        const CIMPropertyList& propertyList_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE, messageId_, queueIds_,
	 nameSpace_,className_,
	 contentLanguages_, acceptLanguages_),
        deepInheritance(deepInheritance_),
        localOnly(localOnly_),
        includeQualifiers(includeQualifiers_),
        includeClassOrigin(includeClassOrigin_),
        propertyList(propertyList_),
        authType(authType_),
        userName(userName_)
    {
    }

    Boolean deepInheritance;
    Boolean localOnly;
    Boolean includeQualifiers;
    Boolean includeClassOrigin;
    CIMPropertyList propertyList;
    String authType;
    String userName;
};

class CIMEnumerateInstanceNamesRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMEnumerateInstanceNamesRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMName& className_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE, messageId_, queueIds_,
	 nameSpace_,className_,
	 contentLanguages_, acceptLanguages_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMEnumerateInstanceNamesRequestMessage(
	const CIMEnumerateInstanceNamesRequestMessage& x)
    : CIMOperationRequestMessage(
        CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE, x.messageId, x.queueIds,
	x.nameSpace, x.className),
        authType(x.authType),
        userName(x.userName)
    {
    }

    virtual void print(PEGASUS_STD(ostream)& os, Boolean printHeader) const
    {
	if (printHeader)
	{
	    os << "CIMEnumerateInstanceNamesRequestMessage\n";
	    os << "{";
	}

	CIMRequestMessage::print(os, false);

	os << "    nameSpace=" << nameSpace << endl;
	os << "    className=" << className << endl;
	os << "    authType=" << authType << endl;
	os << "    userName=" << userName << endl;

	if (printHeader)
	{
	    os << "}";
	}
    }

    String authType;
    String userName;
};

class CIMExecQueryRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMExecQueryRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const String& queryLanguage_,
        const String& query_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(CIM_EXEC_QUERY_REQUEST_MESSAGE, messageId_, queueIds_,
         nameSpace_,CIMName(),
	 contentLanguages_, acceptLanguages_,
	 TYPE_QUERY),
        queryLanguage(queryLanguage_),
        query(query_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMExecQueryRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
	const CIMName className,
        const String& queryLanguage_,
        const String& query_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(CIM_EXEC_QUERY_REQUEST_MESSAGE, messageId_, queueIds_,
         nameSpace_,className,
	 contentLanguages_, acceptLanguages_,
	 TYPE_QUERY),
        queryLanguage(queryLanguage_),
        query(query_),
        authType(authType_),
        userName(userName_)
    {
    }

    String queryLanguage;
    String query;
    String authType;
    String userName;
};

class CIMAssociatorsRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMAssociatorsRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMObjectPath& objectName_,
        const CIMName& assocClass_,
        const CIMName& resultClass_,
        const String& role_,
        const String& resultRole_,
        Boolean includeQualifiers_,
        Boolean includeClassOrigin_,
        const CIMPropertyList& propertyList_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_ASSOCIATORS_REQUEST_MESSAGE, messageId_, queueIds_,
	 nameSpace_,objectName_.getClassName(),
	 contentLanguages_, acceptLanguages_,
	 TYPE_ASSOCIATION),
        objectName(objectName_),
        assocClass(assocClass_),
        resultClass(resultClass_),
        role(role_),
        resultRole(resultRole_),
        includeQualifiers(includeQualifiers_),
        includeClassOrigin(includeClassOrigin_),
        propertyList(propertyList_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMObjectPath objectName;
    CIMName assocClass;
    CIMName resultClass;
    String role;
    String resultRole;
    Boolean includeQualifiers;
    Boolean includeClassOrigin;
    CIMPropertyList propertyList;
    String authType;
    String userName;
};

class CIMAssociatorNamesRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMAssociatorNamesRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMObjectPath& objectName_,
        const CIMName& assocClass_,
        const CIMName& resultClass_,
        const String& role_,
        const String& resultRole_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE, messageId_, queueIds_,
	 nameSpace_,objectName_.getClassName(),
	 contentLanguages_, acceptLanguages_,
	 TYPE_ASSOCIATION),
        objectName(objectName_),
        assocClass(assocClass_),
        resultClass(resultClass_),
        role(role_),
        resultRole(resultRole_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMObjectPath objectName;
    CIMName assocClass;
    CIMName resultClass;
    String role;
    String resultRole;
    String authType;
    String userName;
};

class CIMReferencesRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMReferencesRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMObjectPath& objectName_,
        const CIMName& resultClass_,
        const String& role_,
        Boolean includeQualifiers_,
        Boolean includeClassOrigin_,
        const CIMPropertyList& propertyList_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
         CIM_REFERENCES_REQUEST_MESSAGE, messageId_, queueIds_,
         nameSpace_,objectName_.getClassName(),
	 contentLanguages_, acceptLanguages_,
	 TYPE_ASSOCIATION),
        objectName(objectName_),
        resultClass(resultClass_),
        role(role_),
        includeQualifiers(includeQualifiers_),
        includeClassOrigin(includeClassOrigin_),
        propertyList(propertyList_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMObjectPath objectName;
    CIMName resultClass;
    String role;
    Boolean includeQualifiers;
    Boolean includeClassOrigin;
    CIMPropertyList propertyList;
    String authType;
    String userName;
};

class CIMReferenceNamesRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMReferenceNamesRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMObjectPath& objectName_,
        const CIMName& resultClass_,
        const String& role_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_REFERENCE_NAMES_REQUEST_MESSAGE, messageId_, queueIds_,
	 nameSpace_,objectName_.getClassName(),
	 contentLanguages_, acceptLanguages_,
	 TYPE_ASSOCIATION),
        objectName(objectName_),
        resultClass(resultClass_),
        role(role_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMObjectPath objectName;
    CIMName resultClass;
    String role;
    String authType;
    String userName;
};

class CIMGetPropertyRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMGetPropertyRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMObjectPath& instanceName_,
        const CIMName& propertyName_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_GET_PROPERTY_REQUEST_MESSAGE, messageId_, queueIds_,
	 nameSpace_,instanceName_.getClassName(),
	 contentLanguages_, acceptLanguages_),
        instanceName(instanceName_),
        propertyName(propertyName_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMObjectPath instanceName;
    CIMName propertyName;
    String authType;
    String userName;
};

class CIMSetPropertyRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMSetPropertyRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMObjectPath& instanceName_,
        const CIMName& propertyName_,
        const CIMValue& newValue_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_SET_PROPERTY_REQUEST_MESSAGE, messageId_, queueIds_,
	 nameSpace_,instanceName_.getClassName(),
	 contentLanguages_, acceptLanguages_),
        instanceName(instanceName_),
        propertyName(propertyName_),
        newValue(newValue_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMObjectPath instanceName;
    CIMName propertyName;
    CIMValue newValue;
    String authType;
    String userName;
};

class CIMGetQualifierRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMGetQualifierRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMName& qualifierName_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_GET_QUALIFIER_REQUEST_MESSAGE, messageId_, queueIds_,
	 nameSpace_,CIMName(),
	 contentLanguages_, acceptLanguages_,
	 TYPE_CLASS),
        qualifierName(qualifierName_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMName qualifierName;
    String authType;
    String userName;
};

class CIMSetQualifierRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMSetQualifierRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMQualifierDecl& qualifierDeclaration_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_SET_QUALIFIER_REQUEST_MESSAGE, messageId_, queueIds_,
	 nameSpace_,CIMName(),
	 contentLanguages_, acceptLanguages_,
	 TYPE_CLASS),
        qualifierDeclaration(qualifierDeclaration_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMQualifierDecl qualifierDeclaration;
    String authType;
    String userName;
};

class CIMDeleteQualifierRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMDeleteQualifierRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMName& qualifierName_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_DELETE_QUALIFIER_REQUEST_MESSAGE, messageId_, queueIds_,
	 nameSpace_,CIMName(),
	 contentLanguages_, acceptLanguages_,
	 TYPE_CLASS),
        qualifierName(qualifierName_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMName qualifierName;
    String authType;
    String userName;
};

class CIMEnumerateQualifiersRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMEnumerateQualifiersRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_ENUMERATE_QUALIFIERS_REQUEST_MESSAGE, messageId_, queueIds_,
	 nameSpace_,CIMName(),
	 contentLanguages_, acceptLanguages_,
	 TYPE_CLASS),
        authType(authType_),
        userName(userName_)
    {
    }

    String authType;
    String userName;
};

class CIMInvokeMethodRequestMessage : public CIMOperationRequestMessage
{
public:
    CIMInvokeMethodRequestMessage(
        const String& messageId_,
        const CIMNamespaceName& nameSpace_,
        const CIMObjectPath& instanceName_,
        const CIMName& methodName_,
        const Array<CIMParamValue>& inParameters_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMOperationRequestMessage(
        CIM_INVOKE_METHOD_REQUEST_MESSAGE, messageId_, queueIds_,
	 nameSpace_,instanceName_.getClassName(),
	 contentLanguages_, acceptLanguages_,
	 TYPE_METHOD),
        instanceName(instanceName_),
        methodName(methodName_),
        inParameters(inParameters_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMObjectPath instanceName;
    CIMName methodName;
    Array<CIMParamValue> inParameters;
    String authType;
    String userName;
};

class CIMProcessIndicationRequestMessage : public CIMRequestMessage
{
public:
    CIMProcessIndicationRequestMessage(
        const String & messageId_,
        const CIMNamespaceName & nameSpace_,
        const CIMInstance& indicationInstance_,
        const Array<CIMObjectPath> & subscriptionInstanceNames_,
        const CIMInstance & provider_,
        QueueIdStack queueIds_,
		const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
		const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMRequestMessage(
        CIM_PROCESS_INDICATION_REQUEST_MESSAGE, messageId_, queueIds_,
		 contentLanguages_, acceptLanguages_),
        nameSpace (nameSpace_),
        indicationInstance(indicationInstance_),
        subscriptionInstanceNames(subscriptionInstanceNames_),
        provider(provider_)
    {
    }

    CIMNamespaceName nameSpace;
    CIMInstance indicationInstance;
    Array<CIMObjectPath> subscriptionInstanceNames;
    CIMInstance provider;
};

class CIMConsumeIndicationRequestMessage : public CIMRequestMessage
{
   public:
      CIMConsumeIndicationRequestMessage(
	 const String & messageId_,
	 const CIMNamespaceName & nameSpace_,     // ns of the origin of the indication
	 const CIMInstance & indicationInstance_,
	 const CIMInstance & consumer_provider_,
	 const CIMInstance & consumer_module_,
	 QueueIdStack queueIds_,
	 const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	 const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
	 : CIMRequestMessage(
	    CIM_CONSUME_INDICATION_REQUEST_MESSAGE, messageId_, queueIds_,
            contentLanguages_, acceptLanguages_),
	   nameSpace(nameSpace_),
	   indicationInstance(indicationInstance_),
	   consumer_provider(consumer_provider_),
	   consumer_module(consumer_module_)
      {
      }

      CIMNamespaceName nameSpace;
      CIMInstance indicationInstance;
      CIMInstance consumer_provider;
      CIMInstance consumer_module;
};



class CIMEnableIndicationsRequestMessage : public CIMIndicationRequestMessage
{
public:
    CIMEnableIndicationsRequestMessage(
        const String & messageId_,
        const CIMInstance & provider_,
        const CIMInstance & providerModule_,
        QueueIdStack queueIds_)
    : CIMIndicationRequestMessage(
        CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE,
        messageId_,
        queueIds_,
	provider_,providerModule_)
    {
    }
};

class CIMDisableIndicationsRequestMessage : public CIMIndicationRequestMessage
{
public:
    CIMDisableIndicationsRequestMessage(
        const String & messageId_,
        const CIMInstance & provider_,
        const CIMInstance & providerModule_,
        QueueIdStack queueIds_)
    : CIMIndicationRequestMessage(
        CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE,
        messageId_,
        queueIds_,
	provider_,providerModule_)
    {
    }
};

class CIMNotifyProviderRegistrationRequestMessage : public CIMRequestMessage
{
public:
    enum Operation
    {
        OP_CREATE = 1, OP_DELETE = 2, OP_MODIFY = 3
    };

    CIMNotifyProviderRegistrationRequestMessage(
        const String & messageId_,
        const Operation operation_,
        const CIMInstance & provider_,
        const CIMInstance & providerModule_,
        const CIMName & className_,
        const Array <CIMNamespaceName> & newNamespaces_,
        const Array <CIMNamespaceName> & oldNamespaces_,
        const CIMPropertyList & newPropertyNames_,
        const CIMPropertyList & oldPropertyNames_,
        QueueIdStack queueIds_)
    : CIMRequestMessage(
        CIM_NOTIFY_PROVIDER_REGISTRATION_REQUEST_MESSAGE,
        messageId_, queueIds_),
        provider (provider_),
        providerModule (providerModule_),
        className (className_),
        newNamespaces (newNamespaces_),
        oldNamespaces (oldNamespaces_),
        newPropertyNames (newPropertyNames_),
        oldPropertyNames (oldPropertyNames_),
        operation(operation_)
    {
    }

    CIMInstance provider;
    CIMInstance providerModule;
    CIMName className;
    Array <CIMNamespaceName> newNamespaces;
    Array <CIMNamespaceName> oldNamespaces;
    CIMPropertyList newPropertyNames;
    CIMPropertyList oldPropertyNames;
    Operation operation;
};

class CIMNotifyProviderTerminationRequestMessage : public CIMRequestMessage
{
public:
    CIMNotifyProviderTerminationRequestMessage(
        const String & messageId_,
        const Array <CIMInstance> & providers_,
        QueueIdStack queueIds_)
    : CIMRequestMessage(
        CIM_NOTIFY_PROVIDER_TERMINATION_REQUEST_MESSAGE,
        messageId_, queueIds_),
        providers (providers_)
    {

    }

    Array <CIMInstance> providers;
};

class CIMHandleIndicationRequestMessage : public CIMRequestMessage
{
public:
    CIMHandleIndicationRequestMessage(
        const String& messageId_,
        const CIMNamespaceName & nameSpace_,
        const CIMInstance& handlerInstance_,
        const CIMInstance& indicationInstance_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMRequestMessage(
        CIM_HANDLE_INDICATION_REQUEST_MESSAGE, messageId_, queueIds_,
	 contentLanguages_, acceptLanguages_),
        nameSpace(nameSpace_),
        handlerInstance(handlerInstance_),
        indicationInstance(indicationInstance_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMNamespaceName nameSpace;
    CIMInstance handlerInstance;
    CIMInstance indicationInstance;
    String authType;
    String userName;
};

class CIMCreateSubscriptionRequestMessage : public CIMIndicationRequestMessage
{
public:
    CIMCreateSubscriptionRequestMessage(
        const String& messageId_,
        const CIMNamespaceName & nameSpace_,
        const CIMInstance & subscriptionInstance_,
        const Array<CIMName> & classNames_,
        const CIMInstance & provider_,
        const CIMInstance & providerModule_,
        const CIMPropertyList & propertyList_,
        const Uint16 repeatNotificationPolicy_,
        const String & condition_,
        const String & query_,
        const String & queryLanguage_,
        QueueIdStack queueIds_,
        const String & authType_ = String::EMPTY,
        const String & userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMIndicationRequestMessage(
        CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE,
        messageId_,
        queueIds_,
        provider_,providerModule_,
        contentLanguages_, acceptLanguages_),
        nameSpace (nameSpace_),
        subscriptionInstance(subscriptionInstance_),
        classNames(classNames_),
        propertyList (propertyList_),
        repeatNotificationPolicy (repeatNotificationPolicy_),
        condition (condition_),
        query (query_),
        queryLanguage (queryLanguage_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMNamespaceName nameSpace;
    CIMInstance subscriptionInstance;
    Array <CIMName> classNames;
    CIMPropertyList propertyList;
    Uint16 repeatNotificationPolicy;
    String condition;
    String query;
    String queryLanguage;
    String authType;
    String userName;
};

class CIMModifySubscriptionRequestMessage : public CIMIndicationRequestMessage
{
public:
    CIMModifySubscriptionRequestMessage(
        const String& messageId_,
        const CIMNamespaceName & nameSpace_,
        const CIMInstance & subscriptionInstance_,
        const Array<CIMName> & classNames_,
        const CIMInstance & provider_,
        const CIMInstance & providerModule_,
        const CIMPropertyList & propertyList_,
        const Uint16 repeatNotificationPolicy_,
        const String & condition_,
        const String & query_,
        const String & queryLanguage_,
        QueueIdStack queueIds_,
        const String & authType_ = String::EMPTY,
        const String & userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMIndicationRequestMessage(
        CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE,
        messageId_,
        queueIds_,
        provider_,providerModule_,
	contentLanguages_, acceptLanguages_),
        nameSpace(nameSpace_),
        subscriptionInstance(subscriptionInstance_),
        classNames(classNames_),
        propertyList (propertyList_),
        repeatNotificationPolicy (repeatNotificationPolicy_),
        condition (condition_),
        query (query_),
        queryLanguage (queryLanguage_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMNamespaceName nameSpace;
    CIMInstance subscriptionInstance;
    Array<CIMName> classNames;
    CIMPropertyList propertyList;
    Uint16 repeatNotificationPolicy;
    String condition;
    String query;
    String queryLanguage;
    String authType;
    String userName;
};

class CIMDeleteSubscriptionRequestMessage : public CIMIndicationRequestMessage
{
public:
    CIMDeleteSubscriptionRequestMessage(
        const String& messageId_,
        const CIMNamespaceName & nameSpace_,
        const CIMInstance & subscriptionInstance_,
        const Array<CIMName> & classNames_,
        const CIMInstance & provider_,
        const CIMInstance & providerModule_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY,
	const AcceptLanguages& acceptLanguages_ = AcceptLanguages::EMPTY)
    : CIMIndicationRequestMessage(
        CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE,
        messageId_,
        queueIds_,
        provider_,providerModule_,
        contentLanguages_, acceptLanguages_),
        nameSpace(nameSpace_),
        subscriptionInstance(subscriptionInstance_),
        classNames(classNames_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMNamespaceName nameSpace;
    CIMInstance subscriptionInstance;
    Array<CIMName> classNames;
    String authType;
    String userName;
};

class CIMDisableModuleRequestMessage : public CIMRequestMessage
{
public:
    CIMDisableModuleRequestMessage(
        const String& messageId_,
        const CIMInstance& providerModule_,
        const Array<CIMInstance>& providers_,
	Boolean disableProviderOnly_,
	const Array<Boolean>& indicationProviders_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY)
    : CIMRequestMessage(
        CIM_DISABLE_MODULE_REQUEST_MESSAGE,
        messageId_,
        queueIds_),
        providerModule(providerModule_),
        providers(providers_),
	disableProviderOnly(disableProviderOnly_),
	indicationProviders(indicationProviders_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMInstance providerModule;
    Array<CIMInstance> providers;
    Boolean disableProviderOnly;
    Array<Boolean> indicationProviders;
    String authType;
    String userName;
};

class CIMEnableModuleRequestMessage : public CIMRequestMessage
{
public:
    CIMEnableModuleRequestMessage(
        const String& messageId_,
        const CIMInstance& providerModule_,
        QueueIdStack queueIds_,
        const String& authType_ = String::EMPTY,
        const String& userName_ = String::EMPTY)
    : CIMRequestMessage(
        CIM_ENABLE_MODULE_REQUEST_MESSAGE,
        messageId_,
        queueIds_),
        providerModule(providerModule_),
        authType(authType_),
        userName(userName_)
    {
    }

    CIMInstance providerModule;
    String authType;
    String userName;
};

class CIMNotifyProviderEnableRequestMessage : public CIMRequestMessage
{
public:
    CIMNotifyProviderEnableRequestMessage(
	const String & messageId_,
	const CIMInstance & providerModule_,
	const CIMInstance & provider_,
	const Array <CIMInstance> & capInstances_,
	QueueIdStack queueIds_)
    : CIMRequestMessage(
	CIM_NOTIFY_PROVIDER_ENABLE_REQUEST_MESSAGE,
	messageId_,
        queueIds_),
	providerModule(providerModule_),
	provider(provider_),
	capInstances(capInstances_)
	{
	}
    
    CIMInstance providerModule;
    CIMInstance provider;
    Array <CIMInstance> capInstances;
};

class CIMStopAllProvidersRequestMessage : public CIMRequestMessage
{
   public:
    CIMStopAllProvidersRequestMessage(
        const String& messageId_,
        QueueIdStack queueIds_)
        :
        CIMRequestMessage(
            CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE,
            messageId_,
            queueIds_)
    {
    }
};

class CIMInitializeProviderRequestMessage : public CIMRequestMessage
{
public:
    CIMInitializeProviderRequestMessage(
	const String & messageId_,
	const CIMInstance & providerModule_,
	const CIMInstance & provider_,
	QueueIdStack queueIds_)
    : CIMRequestMessage(
	CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE,
	messageId_,
        queueIds_),
	providerModule(providerModule_),
	provider(provider_)
	{
	}
    
    CIMInstance providerModule;
    CIMInstance provider;
};

class PEGASUS_COMMON_LINKAGE CIMGetClassResponseMessage
    : public CIMResponseMessage
{
public:
    CIMGetClassResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const CIMClass& cimClass_,
		const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY)
    : CIMResponseMessage(CIM_GET_CLASS_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_,
	contentLanguages_),
        cimClass(cimClass_)
    {
    }

    CIMClass cimClass;
};

class CIMGetInstanceResponseMessage : public CIMResponseMessage
{
public:
    CIMGetInstanceResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const CIMInstance& cimInstance_,
		const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY)
    : CIMResponseMessage(CIM_GET_INSTANCE_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_,
	contentLanguages_),
        cimInstance(cimInstance_)
    {
    }

    CIMInstance cimInstance;
};

class CIMExportIndicationResponseMessage : public CIMResponseMessage
{
public:
    CIMExportIndicationResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_)
    : CIMResponseMessage(CIM_EXPORT_INDICATION_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_)
    {
    }
};

class CIMDeleteClassResponseMessage : public CIMResponseMessage
{
public:
    CIMDeleteClassResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_)
    : CIMResponseMessage(CIM_DELETE_CLASS_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_)
    {
    }
};

class CIMDeleteInstanceResponseMessage : public CIMResponseMessage
{
public:
    CIMDeleteInstanceResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_)
    : CIMResponseMessage(CIM_DELETE_INSTANCE_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_)
    {
    }
};

class CIMCreateClassResponseMessage : public CIMResponseMessage
{
public:
    CIMCreateClassResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_)
    : CIMResponseMessage(CIM_CREATE_CLASS_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_)
    {
    }
};

class CIMCreateInstanceResponseMessage : public CIMResponseMessage
{
public:
    CIMCreateInstanceResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const CIMObjectPath& instanceName_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY)
    : CIMResponseMessage(CIM_CREATE_INSTANCE_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_,
	contentLanguages_),
        instanceName(instanceName_)
    {
    }

    CIMObjectPath instanceName;
};

class CIMModifyClassResponseMessage : public CIMResponseMessage
{
public:
    CIMModifyClassResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_)
    : CIMResponseMessage(CIM_MODIFY_CLASS_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_)
    {
    }
};

class CIMModifyInstanceResponseMessage : public CIMResponseMessage
{
public:
    CIMModifyInstanceResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_)
    : CIMResponseMessage(CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_)
    {
    }
};

class CIMEnumerateClassesResponseMessage : public CIMResponseMessage
{
public:
    CIMEnumerateClassesResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const Array<CIMClass>& cimClasses_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY)
    : CIMResponseMessage(CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_,
	contentLanguages_),
        cimClasses(cimClasses_)
    {
    }

    Array<CIMClass> cimClasses;
};

class CIMEnumerateClassNamesResponseMessage : public CIMResponseMessage
{
public:
    CIMEnumerateClassNamesResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const Array<CIMName>& classNames_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY)
    : CIMResponseMessage(CIM_ENUMERATE_CLASS_NAMES_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_,
	contentLanguages_),
        classNames(classNames_)
    {
    }

    Array<CIMName> classNames;
};

class CIMEnumerateInstancesResponseMessage : public CIMResponseMessage
{
public:
    CIMEnumerateInstancesResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const Array<CIMInstance>& cimNamedInstances_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY)
    : CIMResponseMessage(CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_,
	contentLanguages_),
        cimNamedInstances(cimNamedInstances_)
    {
    }

    Array<CIMInstance> cimNamedInstances;
};

class CIMEnumerateInstanceNamesResponseMessage : public CIMResponseMessage
{
public:
    CIMEnumerateInstanceNamesResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const Array<CIMObjectPath>& instanceNames_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY)
    : CIMResponseMessage(CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_,
	contentLanguages_),
        instanceNames(instanceNames_)
    {
    }

    Array<CIMObjectPath> instanceNames;
};

class CIMExecQueryResponseMessage : public CIMResponseMessage
{
public:
    CIMExecQueryResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const Array<CIMObject>& cimObjects_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY)
    : CIMResponseMessage(CIM_EXEC_QUERY_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_,
	contentLanguages_),
        cimObjects(cimObjects_)
    {
    }

    Array<CIMObject> cimObjects;
};

class CIMAssociatorsResponseMessage : public CIMResponseMessage
{
public:
    CIMAssociatorsResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const Array<CIMObject>& cimObjects_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY)
    : CIMResponseMessage(CIM_ASSOCIATORS_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_,
	contentLanguages_),
        cimObjects(cimObjects_)
    {
    }

    Array<CIMObject> cimObjects;
};

class CIMAssociatorNamesResponseMessage : public CIMResponseMessage
{
public:
    CIMAssociatorNamesResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const Array<CIMObjectPath>& objectNames_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY)
    : CIMResponseMessage(CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_,
	contentLanguages_),
        objectNames(objectNames_)
    {
    }

    Array<CIMObjectPath> objectNames;
};

class CIMReferencesResponseMessage : public CIMResponseMessage
{
public:
    CIMReferencesResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const Array<CIMObject>& cimObjects_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY)
    : CIMResponseMessage(CIM_REFERENCES_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_,
	contentLanguages_),
        cimObjects(cimObjects_)
    {
    }

    Array<CIMObject> cimObjects;
};

class CIMReferenceNamesResponseMessage : public CIMResponseMessage
{
public:
    CIMReferenceNamesResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const Array<CIMObjectPath>& objectNames_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY)
    : CIMResponseMessage(CIM_REFERENCE_NAMES_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_,
	contentLanguages_),
        objectNames(objectNames_)
    {
    }

    Array<CIMObjectPath> objectNames;
};

class CIMGetPropertyResponseMessage : public CIMResponseMessage
{
public:
    CIMGetPropertyResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const CIMValue& value_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY)
    : CIMResponseMessage(CIM_GET_PROPERTY_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_,
	contentLanguages_),
        value(value_)
    {
    }

    CIMValue value;
};

class CIMSetPropertyResponseMessage : public CIMResponseMessage
{
public:
    CIMSetPropertyResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_)
    : CIMResponseMessage(CIM_SET_PROPERTY_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_)
    {
    }
};

class CIMGetQualifierResponseMessage : public CIMResponseMessage
{
public:
    CIMGetQualifierResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const CIMQualifierDecl& cimQualifierDecl_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY)
    : CIMResponseMessage(CIM_GET_QUALIFIER_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_,
	contentLanguages_),
        cimQualifierDecl(cimQualifierDecl_)
    {
    }

    CIMQualifierDecl cimQualifierDecl;
};

class CIMSetQualifierResponseMessage : public CIMResponseMessage
{
public:

    CIMSetQualifierResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_)
    :
    CIMResponseMessage(CIM_SET_QUALIFIER_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_)
    {
    }
};

class CIMDeleteQualifierResponseMessage : public CIMResponseMessage
{
public:

    CIMDeleteQualifierResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_)
    :
    CIMResponseMessage(CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_)
    {
    }
};

class CIMEnumerateQualifiersResponseMessage : public CIMResponseMessage
{
public:
    CIMEnumerateQualifiersResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const Array<CIMQualifierDecl>& qualifierDeclarations_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY)
    : CIMResponseMessage(CIM_ENUMERATE_QUALIFIERS_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_,
	contentLanguages_),
        qualifierDeclarations(qualifierDeclarations_)
    {
    }

    Array<CIMQualifierDecl> qualifierDeclarations;
};

class CIMInvokeMethodResponseMessage : public CIMResponseMessage
{
public:
    CIMInvokeMethodResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const CIMValue& retValue_,
        const Array<CIMParamValue>& outParameters_,
        const CIMName& methodName_,
	const ContentLanguages& contentLanguages_ = ContentLanguages::EMPTY)
    : CIMResponseMessage(CIM_INVOKE_METHOD_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_,
	contentLanguages_),
        retValue(retValue_),
        outParameters(outParameters_),
        methodName(methodName_)
    {
    }

    CIMValue retValue;
    Array<CIMParamValue> outParameters;
    CIMName methodName;
};

class CIMProcessIndicationResponseMessage : public CIMResponseMessage
{
public:
    CIMProcessIndicationResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_)
    : CIMResponseMessage(CIM_CREATE_INSTANCE_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_)
    {
    }
};

class CIMHandleIndicationResponseMessage : public CIMResponseMessage
{
public:
    CIMHandleIndicationResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_)
    : CIMResponseMessage(CIM_HANDLE_INDICATION_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_)
    {
    }
};

class CIMCreateSubscriptionResponseMessage : public CIMResponseMessage
{
public:
    CIMCreateSubscriptionResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_)
    : CIMResponseMessage(
        CIM_CREATE_SUBSCRIPTION_RESPONSE_MESSAGE,
        messageId_,
        cimException_,
        queueIds_)
    {
    }
};

class CIMModifySubscriptionResponseMessage : public CIMResponseMessage
{
public:
    CIMModifySubscriptionResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_)
    : CIMResponseMessage(
        CIM_MODIFY_SUBSCRIPTION_RESPONSE_MESSAGE,
        messageId_,
        cimException_,
        queueIds_)
    {
    }
};

class CIMDeleteSubscriptionResponseMessage : public CIMResponseMessage
{
public:
    CIMDeleteSubscriptionResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_)
    : CIMResponseMessage(
        CIM_DELETE_SUBSCRIPTION_RESPONSE_MESSAGE,
        messageId_,
        cimException_,
        queueIds_)
    {
    }
};

class CIMEnableIndicationsResponseMessage : public CIMResponseMessage
{
public:
    CIMEnableIndicationsResponseMessage(
        const String & messageId_,
        const CIMException & cimException_,
        const QueueIdStack & queueIds_)
    : CIMResponseMessage(
        CIM_ENABLE_INDICATIONS_RESPONSE_MESSAGE,
        messageId_,
        cimException_,
        queueIds_)
    {
    }
};

class CIMDisableIndicationsResponseMessage : public CIMResponseMessage
{
public:
    CIMDisableIndicationsResponseMessage(
        const String & messageId_,
        const CIMException & cimException_,
        QueueIdStack queueIds_)
    : CIMResponseMessage(
        CIM_DISABLE_INDICATIONS_RESPONSE_MESSAGE,
        messageId_,
        cimException_,
        queueIds_)
    {
    }
};

class PEGASUS_COMMON_LINKAGE CIMDisableModuleResponseMessage
    : public CIMResponseMessage
{
public:
    CIMDisableModuleResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const Array<Uint16>& operationalStatus_)
    : CIMResponseMessage(CIM_DISABLE_MODULE_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_),
        operationalStatus(operationalStatus_)
    {
    }

    Array<Uint16> operationalStatus;
};

class PEGASUS_COMMON_LINKAGE CIMEnableModuleResponseMessage
    : public CIMResponseMessage
{
public:
    CIMEnableModuleResponseMessage(
        const String& messageId_,
        const CIMException& cimException_,
        const QueueIdStack& queueIds_,
        const Array<Uint16>& operationalStatus_)
    : CIMResponseMessage(CIM_ENABLE_MODULE_RESPONSE_MESSAGE,
        messageId_, cimException_, queueIds_),
        operationalStatus(operationalStatus_)
    {
    }

    Array<Uint16> operationalStatus;
};

class PEGASUS_COMMON_LINKAGE CIMStopAllProvidersResponseMessage
   : public CIMResponseMessage
{
   public:

      CIMStopAllProvidersResponseMessage(
         const String& messageId_,
         const CIMException& cimException_,
         const QueueIdStack& queueIds_)
         :
         CIMResponseMessage(CIM_STOP_ALL_PROVIDERS_RESPONSE_MESSAGE,
                            messageId_, cimException_, queueIds_)
      {
      }
};

class PEGASUS_COMMON_LINKAGE CIMNotifyProviderEnableResponseMessage
   : public CIMResponseMessage
{
   public:

      CIMNotifyProviderEnableResponseMessage(
         const String& messageId_,
         const CIMException& cimException_,
         const QueueIdStack& queueIds_)
         :
         CIMResponseMessage(CIM_NOTIFY_PROVIDER_ENABLE_RESPONSE_MESSAGE,
                            messageId_, cimException_, queueIds_)
      {
      }
};

class PEGASUS_COMMON_LINKAGE CIMInitializeProviderResponseMessage
   : public CIMResponseMessage
{
   public:

      CIMInitializeProviderResponseMessage(
         const String& messageId_,
         const CIMException& cimException_,
         const QueueIdStack& queueIds_)
         :
         CIMResponseMessage(CIM_INITIALIZE_PROVIDER_RESPONSE_MESSAGE,
                            messageId_, cimException_, queueIds_)
      {
      }
};

PEGASUS_NAMESPACE_END

#endif /* Pegasus_CIMMessage_h */