(file) Return to OperationResponseHandler.h CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2

Diff for /pegasus/src/Pegasus/ProviderManager2/OperationResponseHandler.h between version 1.22 and 1.30.2.1

version 1.22, 2005/03/11 01:51:56 version 1.30.2.1, 2006/02/28 19:53:30
Line 1 
Line 1 
 //%2005////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
Line 8 
Line 8 
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 // EMC Corporation; VERITAS Software Corporation; The Open Group. // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 43 
Line 45 
 #define Pegasus_OperationResponseHandler_h #define Pegasus_OperationResponseHandler_h
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Server/Linkage.h>  
 #include <Pegasus/Common/CIMMessage.h> #include <Pegasus/Common/CIMMessage.h>
 #include <Pegasus/Common/MessageQueueService.h> #include <Pegasus/Common/MessageQueueService.h>
 #include <Pegasus/Common/Constants.h> #include <Pegasus/Common/Constants.h>
 #include <Pegasus/Common/ContentLanguages.h>  // l10n  
  
 #include <Pegasus/Common/CIMClass.h> #include <Pegasus/Common/CIMClass.h>
 #include <Pegasus/Common/CIMInstance.h> #include <Pegasus/Common/CIMInstance.h>
Line 58 
Line 58 
 #include <Pegasus/Common/OperationContextInternal.h> #include <Pegasus/Common/OperationContextInternal.h>
  
 #include <Pegasus/Common/ObjectNormalizer.h> #include <Pegasus/Common/ObjectNormalizer.h>
 #include <Pegasus/Common/ResponseHandler.h>  
 #include <Pegasus/Common/Logger.h>  
 #include <Pegasus/Common/XmlWriter.h>  
  
   #include <Pegasus/Common/ResponseHandler.h>
 #include <Pegasus/ProviderManager2/SimpleResponseHandler.h> #include <Pegasus/ProviderManager2/SimpleResponseHandler.h>
   
 #include <Pegasus/ProviderManager2/Linkage.h> #include <Pegasus/ProviderManager2/Linkage.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   typedef void (*PEGASUS_RESPONSE_CHUNK_CALLBACK_T)(
       CIMRequestMessage* request, CIMResponseMessage* response);
   
 class PEGASUS_PPM_LINKAGE OperationResponseHandler class PEGASUS_PPM_LINKAGE OperationResponseHandler
 { {
     friend class SimpleResponseHandler;     friend class SimpleResponseHandler;
Line 74 
Line 76 
 public: public:
     OperationResponseHandler(     OperationResponseHandler(
         CIMRequestMessage * request,         CIMRequestMessage * request,
         CIMResponseMessage * response);          CIMResponseMessage* response,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
  
     virtual ~OperationResponseHandler(void);     virtual ~OperationResponseHandler(void);
  
     CIMRequestMessage * getRequest(void) const      CIMRequestMessage * getRequest(void) const;
     {  
         return(_request);  
     }  
  
     CIMResponseMessage * getResponse(void) const      CIMResponseMessage * getResponse(void) const;
     {  
         return(_response);  
     }  
  
     virtual void setStatus(     virtual void setStatus(
         const Uint32 code,         const Uint32 code,
         const String & message = String::EMPTY)          const String & message = String::EMPTY);
     {  
         _response->cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(code), message);  
     }  
  
     virtual void setStatus(     virtual void setStatus(
         const Uint32 code,         const Uint32 code,
         const ContentLanguages & langs,          const ContentLanguageList & langs,
         const String & message = String::EMPTY)          const String & message = String::EMPTY);
     {  
         _response->cimException =  
             PEGASUS_CIM_EXCEPTION_LANG(  
             langs,  
             CIMStatusCode(code),  
             message);  
     }  
  
 protected: protected:
     // the default for all derived handlers. Some handlers may not apply     // the default for all derived handlers. Some handlers may not apply
     // async behavior because their callers cannot handle partial responses.     // async behavior because their callers cannot handle partial responses.
     virtual Boolean isAsync(void) const      virtual Boolean isAsync(void) const;
     {  
         return(true);  
     }  
  
     // send (deliver) asynchronously     // send (deliver) asynchronously
     virtual void send(Boolean isComplete);     virtual void send(Boolean isComplete);
  
     // transfer any objects from handler to response. this does not clear()     // transfer any objects from handler to response. this does not clear()
     virtual void transfer(void)      virtual void transfer(void);
     {  
     }  
  
     // validate whatever is necessary before the transfer     // validate whatever is necessary before the transfer
     virtual void validate(void)      virtual void validate(void);
     {  
     }  
  
     virtual String getClass(void) const      virtual String getClass(void) const;
     {  
         return(String("OperationResponseHandler"));  
     }  
  
     Uint32 getResponseObjectTotal(void) const      Uint32 getResponseObjectTotal(void) const;
     {  
         return(_responseObjectTotal);  
     }  
  
     // there can be many objects per message (or none at all - i.e complete())     // there can be many objects per message (or none at all - i.e complete())
     Uint32 getResponseMessageTotal(void) const      Uint32 getResponseMessageTotal(void) const;
     {  
         return(_responseMessageTotal);  
     }  
  
     Uint32 getResponseObjectThreshold(void) const      Uint32 getResponseObjectThreshold(void) const;
     {  
         return(_responseObjectThreshold);  
     }  
  
     CIMRequestMessage * _request;     CIMRequestMessage * _request;
     CIMResponseMessage * _response;     CIMResponseMessage * _response;
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T _responseChunkCallback;
  
 private: private:
     Uint32 _responseObjectTotal;     Uint32 _responseObjectTotal;
Line 159 
Line 128 
  
 }; };
  
 class GetInstanceResponseHandler : public OperationResponseHandler, public SimpleInstanceResponseHandler  class PEGASUS_PPM_LINKAGE GetInstanceResponseHandler : public OperationResponseHandler, public SimpleInstanceResponseHandler
 { {
 public: public:
     GetInstanceResponseHandler(     GetInstanceResponseHandler(
         CIMGetInstanceRequestMessage * request,         CIMGetInstanceRequestMessage * request,
         CIMGetInstanceResponseMessage * response)          CIMGetInstanceResponseMessage* response,
     : OperationResponseHandler(request, response)          PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
     {  
         #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION  
         // Attempt to get the cached class definition used to validate results of this  
         // operation. If it does not exist, then this feature is disabled for this  
         // operation.  
         CIMClass cimClass;  
   
         try  
         {  
             CachedClassDefinitionContainer container =  
                 request->operationContext.get(CachedClassDefinitionContainer::NAME);  
   
             cimClass = container.getClass();  
   
         }  
         catch(Exception &)  
         {  
             // Do nothing. Container is missing, which implies normalization is disabled  
             // for this operation.  
         }  
   
         _normalizer =  
             ObjectNormalizer(  
                 cimClass,  
                 request->includeQualifiers,  
                 request->includeClassOrigin);  
         #endif  
     }  
  
     virtual void deliver(const CIMInstance & cimInstance)      virtual void deliver(const CIMInstance & cimInstance);
       virtual void deliver(const Array<CIMInstance> & cimInstanceArray)
     {     {
         if(cimInstance.isUninitialized())          SimpleInstanceResponseHandler::deliver(cimInstanceArray);
         {  
             MessageLoaderParms message(  
                 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",  
                 "The object is not initialized.");  
   
             throw CIMException(CIM_ERR_FAILED, message);  
         }         }
  
         #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION      virtual void complete(void);
         SimpleInstanceResponseHandler::deliver(_normalizer.processInstance(cimInstance));  
         #else  
         SimpleInstanceResponseHandler::deliver(cimInstance);  
         #endif  
     }  
  
 protected: protected:
     virtual String getClass(void) const      virtual String getClass(void) const;
     {  
         return(String("GetInstanceResponseHandler"));  
     }  
  
     virtual void transfer(void)      virtual void transfer(void);
     {  
         if(size() > 0)  
         {  
             CIMGetInstanceResponseMessage & msg =  
                 *static_cast<CIMGetInstanceResponseMessage *>(getResponse());  
   
             msg.cimInstance = getObjects()[0];  
         }  
     }  
  
     virtual void validate(void)      virtual void validate(void);
     {  
         if(getResponseObjectTotal() == 0)  
         {  
             // error? provider claims success,  
             // but did not deliver an instance.  
             setStatus(CIM_ERR_NOT_FOUND);  
         }  
     }  
  
 private: private:
     ObjectNormalizer _normalizer;     ObjectNormalizer _normalizer;
  
 }; };
  
 class EnumerateInstancesResponseHandler : public OperationResponseHandler, public SimpleInstanceResponseHandler  class PEGASUS_PPM_LINKAGE EnumerateInstancesResponseHandler : public OperationResponseHandler, public SimpleInstanceResponseHandler
 { {
 public: public:
     EnumerateInstancesResponseHandler(     EnumerateInstancesResponseHandler(
         CIMEnumerateInstancesRequestMessage * request,         CIMEnumerateInstancesRequestMessage * request,
         CIMEnumerateInstancesResponseMessage * response)          CIMEnumerateInstancesResponseMessage* response,
     : OperationResponseHandler(request, response)          PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
     {  
         #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION  
         // Attempt to get the cached class definition used to validate results of this  
         // operation. If it does not exist, then this feature is disabled for this  
         // operation.  
         CIMClass cimClass;  
   
         try  
         {  
             CachedClassDefinitionContainer container =  
                 request->operationContext.get(CachedClassDefinitionContainer::NAME);  
  
             cimClass = container.getClass();      virtual void deliver(const CIMInstance & cimInstance);
         }      virtual void deliver(const Array<CIMInstance> & cimInstanceArray)
         catch(Exception &)  
         {         {
             // Do nothing. Container is missing, which implies normalization is disabled          SimpleInstanceResponseHandler::deliver(cimInstanceArray);
             // for this operation.  
         }  
   
         _normalizer =  
             ObjectNormalizer(  
                 cimClass,  
                 request->includeQualifiers,  
                 request->includeClassOrigin);  
         #endif  
     }  
   
     virtual void deliver(const CIMInstance & cimInstance)  
     {  
         if(cimInstance.isUninitialized())  
         {  
             MessageLoaderParms message(  
                 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",  
                 "The object is not initialized.");  
   
             throw CIMException(CIM_ERR_FAILED, message);  
         }  
   
         #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION  
         SimpleInstanceResponseHandler::deliver(_normalizer.processInstance(cimInstance));  
         #else  
         SimpleInstanceResponseHandler::deliver(cimInstance);  
         #endif  
     }     }
  
 protected: protected:
     virtual String getClass(void) const      virtual String getClass(void) const;
     {  
         return(String("EnumerateInstancesResponseHandler"));  
     }  
   
     virtual void transfer(void)  
     {  
         CIMEnumerateInstancesResponseMessage & msg =  
             *static_cast<CIMEnumerateInstancesResponseMessage *>(getResponse());  
  
         msg.cimNamedInstances = getObjects();      virtual void transfer(void);
     }  
  
 private: private:
     ObjectNormalizer _normalizer;     ObjectNormalizer _normalizer;
  
 }; };
  
 class EnumerateInstanceNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler  class PEGASUS_PPM_LINKAGE EnumerateInstanceNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler
 { {
 public: public:
     EnumerateInstanceNamesResponseHandler(     EnumerateInstanceNamesResponseHandler(
         CIMEnumerateInstanceNamesRequestMessage * request,         CIMEnumerateInstanceNamesRequestMessage * request,
         CIMEnumerateInstanceNamesResponseMessage * response)          CIMEnumerateInstanceNamesResponseMessage* response,
     : OperationResponseHandler(request, response)          PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
     {  
         #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION  
         // Attempt to get the cached class definition used to validate results of this  
         // operation. If it does not exist, then this feature is disabled for this  
         // operation.  
         CIMClass cimClass;  
   
         try  
         {  
             CachedClassDefinitionContainer container =  
                 request->operationContext.get(CachedClassDefinitionContainer::NAME);  
   
             cimClass = container.getClass();  
         }  
         catch(Exception &)  
         {  
             // Do nothing. Container is missing, which implies normalization is disabled  
             // for this operation.  
         }  
  
         _normalizer =      virtual void deliver(const CIMObjectPath & cimObjectPath);
             ObjectNormalizer(      virtual void deliver(const Array<CIMObjectPath> & cimObjectPathArray)
                 cimClass,  
                 false,  
                 false);  
         #endif  
     }  
   
     virtual void deliver(const CIMObjectPath & cimObjectPath)  
     {  
         if(cimObjectPath.getClassName().isNull())  
         {         {
             MessageLoaderParms message(          SimpleObjectPathResponseHandler::deliver(cimObjectPathArray);
                 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",  
                 "The object is not initialized.");  
   
             throw CIMException(CIM_ERR_FAILED, message);  
         }  
   
         #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION  
         SimpleObjectPathResponseHandler::deliver(_normalizer.processInstanceObjectPath(cimObjectPath));  
         #else  
         SimpleObjectPathResponseHandler::deliver(cimObjectPath);  
         #endif  
     }     }
  
 protected: protected:
     virtual String getClass(void) const      virtual String getClass(void) const;
     {  
         return(String("EnumerateInstanceNamesResponseHandler"));  
     }  
   
     virtual void transfer(void)  
     {  
         CIMEnumerateInstanceNamesResponseMessage & msg =  
             *static_cast<CIMEnumerateInstanceNamesResponseMessage *>(getResponse());  
  
         msg.instanceNames = getObjects();      virtual void transfer(void);
     }  
  
 private: private:
     ObjectNormalizer _normalizer;     ObjectNormalizer _normalizer;
  
 }; };
  
 class CreateInstanceResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler  class PEGASUS_PPM_LINKAGE CreateInstanceResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler
 { {
 public: public:
     CreateInstanceResponseHandler(     CreateInstanceResponseHandler(
         CIMCreateInstanceRequestMessage * request,         CIMCreateInstanceRequestMessage * request,
         CIMCreateInstanceResponseMessage * response)          CIMCreateInstanceResponseMessage* response,
     : OperationResponseHandler(request, response)          PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
     {  
     }  
  
     virtual void deliver(const CIMObjectPath & cimObjectPath)      virtual void deliver(const CIMObjectPath & cimObjectPath);
     {      virtual void deliver(const Array<CIMObjectPath> & cimObjectPathArray)
         if(cimObjectPath.getClassName().isNull())  
         {         {
             MessageLoaderParms message(          SimpleObjectPathResponseHandler::deliver(cimObjectPathArray);
                 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",  
                 "The object is not initialized.");  
   
             throw CIMException(CIM_ERR_FAILED, message);  
         }         }
  
         SimpleObjectPathResponseHandler::deliver(cimObjectPath);      virtual void complete(void);
     }  
  
 protected: protected:
     virtual String getClass(void) const      virtual String getClass(void) const;
     {  
         return(String("CreateInstanceResponseHandler"));  
     }  
   
     #if 0  
     // ATTN: is it an error to not return instance name?  
     virtual void validate(void)  
     {  
         if(getResponseObjectTotal() == 0)  
         {  
             setStatus(CIM_ERR_NOT_FOUND);  
         }  
     }  
     #endif  
  
     virtual void transfer(void)      virtual void transfer(void);
     {  
         if(size() > 0)  
         {  
             CIMCreateInstanceResponseMessage & msg =  
                 *static_cast<CIMCreateInstanceResponseMessage *>(getResponse());  
  
             msg.instanceName = getObjects()[0];  
         }  
     }  
 }; };
  
 class ModifyInstanceResponseHandler : public OperationResponseHandler, public SimpleResponseHandler  class PEGASUS_PPM_LINKAGE ModifyInstanceResponseHandler : public OperationResponseHandler, public SimpleResponseHandler
 { {
 public: public:
     ModifyInstanceResponseHandler(     ModifyInstanceResponseHandler(
         CIMModifyInstanceRequestMessage * request,         CIMModifyInstanceRequestMessage * request,
         CIMModifyInstanceResponseMessage * response)          CIMModifyInstanceResponseMessage* response,
     : OperationResponseHandler(request, response)          PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
     {  
     }  
  
 protected: protected:
     virtual String getClass(void) const      virtual String getClass(void) const;
     {  
         return(String("ModifyInstanceResponseHandler"));  
     }  
 }; };
  
 class DeleteInstanceResponseHandler : public OperationResponseHandler, public SimpleResponseHandler  class PEGASUS_PPM_LINKAGE DeleteInstanceResponseHandler : public OperationResponseHandler, public SimpleResponseHandler
 { {
 public: public:
     DeleteInstanceResponseHandler(     DeleteInstanceResponseHandler(
         CIMDeleteInstanceRequestMessage * request,         CIMDeleteInstanceRequestMessage * request,
         CIMDeleteInstanceResponseMessage * response)          CIMDeleteInstanceResponseMessage* response,
     : OperationResponseHandler(request, response)          PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
     {  
     }  
  
 protected: protected:
     virtual String getClass(void) const      virtual String getClass(void) const;
     {  
         return(String("DeleteInstanceResponseHandler"));  
     }  
  
 }; };
  
 class GetPropertyResponseHandler : public OperationResponseHandler, public SimpleValueResponseHandler  class PEGASUS_PPM_LINKAGE GetPropertyResponseHandler : public OperationResponseHandler, public SimpleValueResponseHandler
 { {
 public: public:
     GetPropertyResponseHandler(     GetPropertyResponseHandler(
         CIMGetPropertyRequestMessage * request,         CIMGetPropertyRequestMessage * request,
         CIMGetPropertyResponseMessage * response)          CIMGetPropertyResponseMessage* response,
     : OperationResponseHandler(request, response)          PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
     {  
     }  
  
     virtual void deliver(const CIMValue & cimValue)      virtual void deliver(const CIMValue & cimValue);
     {      virtual void deliver(const Array<CIMValue> & cimValueArray)
         if(cimValue.isNull())  
         {         {
             MessageLoaderParms message(          SimpleValueResponseHandler::deliver(cimValueArray);
                 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",  
                 "The object is not initialized.");  
   
             throw CIMException(CIM_ERR_FAILED, message);  
         }  
   
         SimpleValueResponseHandler::deliver(cimValue);  
     }     }
  
 protected: protected:
     virtual String getClass(void) const      virtual String getClass(void) const;
     {  
         return(String("GetPropertyResponseHandler"));  
     }  
  
     virtual void transfer(void)      virtual void transfer(void);
     {  
         if(size() > 0)  
         {  
             CIMGetPropertyResponseMessage & msg =  
                 *static_cast<CIMGetPropertyResponseMessage *>(getResponse());  
  
             msg.value = getObjects()[0];      virtual void validate(void);
         }  
     }  
  
     virtual void validate(void)  
     {  
         // error? provider claims success,  
         // but did not deliver an instance.  
         if(getResponseObjectTotal() == 0)  
         {  
             setStatus(CIM_ERR_NOT_FOUND);  
         }  
     }  
 }; };
  
 class SetPropertyResponseHandler : public OperationResponseHandler, public SimpleResponseHandler  class PEGASUS_PPM_LINKAGE SetPropertyResponseHandler : public OperationResponseHandler, public SimpleResponseHandler
 { {
 public: public:
     SetPropertyResponseHandler(     SetPropertyResponseHandler(
         CIMSetPropertyRequestMessage * request,         CIMSetPropertyRequestMessage * request,
         CIMSetPropertyResponseMessage * response)          CIMSetPropertyResponseMessage* response,
     : OperationResponseHandler(request, response)          PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
     {  
     }  
  
 protected: protected:
     virtual String getClass(void) const      virtual String getClass(void) const;
     {  
         return(String("SetPropertyResponseHandler"));  
     }  
  
 }; };
  
 class ExecQueryResponseHandler : public OperationResponseHandler, public SimpleInstance2ObjectResponseHandler  class PEGASUS_PPM_LINKAGE ExecQueryResponseHandler : public OperationResponseHandler, public SimpleInstance2ObjectResponseHandler
 { {
 public: public:
     ExecQueryResponseHandler(     ExecQueryResponseHandler(
         CIMExecQueryRequestMessage * request,         CIMExecQueryRequestMessage * request,
         CIMExecQueryResponseMessage * response)          CIMExecQueryResponseMessage* response,
     : OperationResponseHandler(request, response)          PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
     {  
     }  
  
     virtual void deliver(const CIMInstance & cimInstance)      virtual void deliver(const CIMInstance & cimInstance);
       virtual void deliver(const Array<CIMInstance> & cimInstanceArray)
     {     {
         if(cimInstance.isUninitialized())          SimpleInstance2ObjectResponseHandler::deliver(cimInstanceArray);
         {  
             MessageLoaderParms message(  
                 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",  
                 "The object is not initialized.");  
   
             throw CIMException(CIM_ERR_FAILED, message);  
         }  
   
         SimpleInstance2ObjectResponseHandler::deliver(cimInstance);  
     }     }
  
 protected: protected:
     virtual String getClass(void) const      virtual String getClass(void) const;
     {  
         return(String("ExecQueryResponseHandler"));  
     }  
  
     virtual void transfer(void)      virtual void transfer(void);
     {  
         CIMExecQueryResponseMessage & msg =  
             *static_cast<CIMExecQueryResponseMessage *>(getResponse());  
  
         msg.cimObjects = getObjects();      virtual Boolean isAsync(void) const;
     }  
  
     virtual Boolean isAsync(void) const  
     {  
         return(false);  
     }  
 }; };
  
 class AssociatorsResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler  class PEGASUS_PPM_LINKAGE AssociatorsResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler
 { {
 public: public:
     AssociatorsResponseHandler(     AssociatorsResponseHandler(
         CIMAssociatorsRequestMessage * request,         CIMAssociatorsRequestMessage * request,
         CIMAssociatorsResponseMessage * response)          CIMAssociatorsResponseMessage* response,
     : OperationResponseHandler(request, response)          PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
     {  
     }  
  
     virtual void deliver(const CIMObject & cimObject)      virtual void deliver(const CIMObject & cimObject);
       virtual void deliver(const Array<CIMObject> & cimObjectArray)
     {     {
         if(cimObject.isUninitialized())          SimpleObjectResponseHandler::deliver(cimObjectArray);
         {  
             MessageLoaderParms message(  
                 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",  
                 "The object is not initialized.");  
   
             throw CIMException(CIM_ERR_FAILED, message);  
         }  
   
         SimpleObjectResponseHandler::deliver(cimObject);  
     }     }
  
 protected: protected:
     virtual String getClass(void) const      virtual String getClass(void) const;
     {  
         return(String("AssociatorsResponseHandler"));  
     }  
  
     virtual void transfer(void)      virtual void transfer(void);
     {  
         CIMAssociatorsResponseMessage & msg =  
             *static_cast<CIMAssociatorsResponseMessage *>(getResponse());  
  
         msg.cimObjects = getObjects();  
     }  
 }; };
  
 class AssociatorNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler  class PEGASUS_PPM_LINKAGE AssociatorNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler
 { {
 public: public:
     AssociatorNamesResponseHandler(     AssociatorNamesResponseHandler(
         CIMAssociatorNamesRequestMessage * request,         CIMAssociatorNamesRequestMessage * request,
         CIMAssociatorNamesResponseMessage * response)          CIMAssociatorNamesResponseMessage* response,
     : OperationResponseHandler(request, response)          PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
     {  
     }  
  
     virtual void deliver(const CIMObjectPath & cimObjectPath)      virtual void deliver(const CIMObjectPath & cimObjectPath);
       virtual void deliver(const Array<CIMObjectPath> & cimObjectPathArray)
     {     {
         if(cimObjectPath.getClassName().isNull())          SimpleObjectPathResponseHandler::deliver(cimObjectPathArray);
         {  
             MessageLoaderParms message(  
                 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",  
                 "The object is not initialized.");  
   
             throw CIMException(CIM_ERR_FAILED, message);  
         }  
   
         SimpleObjectPathResponseHandler::deliver(cimObjectPath);  
     }     }
  
 protected: protected:
     virtual String getClass(void) const      virtual String getClass(void) const;
     {  
         return(String("AssociatorNamesResponseHandler"));  
     }  
  
     virtual void transfer(void)      virtual void transfer(void);
     {  
         CIMAssociatorNamesResponseMessage & msg =  
             *static_cast<CIMAssociatorNamesResponseMessage *>(getResponse());  
  
         msg.objectNames = getObjects();  
     }  
 }; };
  
 class ReferencesResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler  class PEGASUS_PPM_LINKAGE ReferencesResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler
 { {
 public: public:
     ReferencesResponseHandler(     ReferencesResponseHandler(
         CIMReferencesRequestMessage * request,         CIMReferencesRequestMessage * request,
         CIMReferencesResponseMessage * response)          CIMReferencesResponseMessage* response,
     : OperationResponseHandler(request, response)          PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
     {  
     }  
  
     virtual void deliver(const CIMObject & cimObject)      virtual void deliver(const CIMObject & cimObject);
       virtual void deliver(const Array<CIMObject> & cimObjectArray)
     {     {
         if(cimObject.isUninitialized())          SimpleObjectResponseHandler::deliver(cimObjectArray);
         {  
             MessageLoaderParms message(  
                 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",  
                 "The object is not initialized.");  
   
             throw CIMException(CIM_ERR_FAILED, message);  
         }  
   
         SimpleObjectResponseHandler::deliver(cimObject);  
     }     }
  
 protected: protected:
     virtual String getClass(void) const      virtual String getClass(void) const;
     {  
         return(String("ReferencesResponseHandler"));  
     }  
  
     virtual void transfer(void)      virtual void transfer(void);
     {  
         CIMReferencesResponseMessage & msg =  
             *static_cast<CIMReferencesResponseMessage *>(getResponse());  
  
         msg.cimObjects = getObjects();  
     }  
 }; };
  
 class ReferenceNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler  class PEGASUS_PPM_LINKAGE ReferenceNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler
 { {
 public: public:
     ReferenceNamesResponseHandler(     ReferenceNamesResponseHandler(
         CIMReferenceNamesRequestMessage * request,         CIMReferenceNamesRequestMessage * request,
         CIMReferenceNamesResponseMessage * response)          CIMReferenceNamesResponseMessage* response,
     : OperationResponseHandler(request, response)          PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
     {  
     }  
  
     virtual void deliver(const CIMObjectPath & cimObjectPath)      virtual void deliver(const CIMObjectPath & cimObjectPath);
       virtual void deliver(const Array<CIMObjectPath> & cimObjectPathArray)
     {     {
         if(cimObjectPath.getClassName().isNull())          SimpleObjectPathResponseHandler::deliver(cimObjectPathArray);
         {  
             MessageLoaderParms message(  
                 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",  
                 "The object is not initialized.");  
   
             throw CIMException(CIM_ERR_FAILED, message);  
         }  
   
         SimpleObjectPathResponseHandler::deliver(cimObjectPath);  
     }     }
  
 protected: protected:
     virtual String getClass(void) const      virtual String getClass(void) const;
     {  
         return(String("ReferenceNamesResponseHandler"));  
     }  
  
     virtual void transfer(void)      virtual void transfer(void);
     {  
         CIMReferenceNamesResponseMessage & msg =  
             *static_cast<CIMReferenceNamesResponseMessage *>(getResponse());  
  
         msg.objectNames = getObjects();  
     }  
 }; };
  
 class InvokeMethodResponseHandler : public OperationResponseHandler, public SimpleMethodResultResponseHandler  class PEGASUS_PPM_LINKAGE InvokeMethodResponseHandler : public OperationResponseHandler, public SimpleMethodResultResponseHandler
 { {
 public: public:
     InvokeMethodResponseHandler(     InvokeMethodResponseHandler(
         CIMInvokeMethodRequestMessage * request,         CIMInvokeMethodRequestMessage * request,
         CIMInvokeMethodResponseMessage * response)          CIMInvokeMethodResponseMessage* response,
     : OperationResponseHandler(request, response)          PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
     {  
     }  
   
     virtual void deliverParamValue(const CIMParamValue & cimParamValue)  
     {  
         if(cimParamValue.isUninitialized())  
         {  
             MessageLoaderParms message(  
                 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",  
                 "The object is not initialized.");  
   
             throw CIMException(CIM_ERR_FAILED, message);  
         }  
   
         SimpleMethodResultResponseHandler::deliverParamValue(cimParamValue);  
     }  
  
     virtual void deliver(const CIMValue & cimValue)      virtual void deliverParamValue(const CIMParamValue & cimParamValue);
     {      virtual void deliverParamValue(
         if(cimValue.isNull())          const Array<CIMParamValue> & cimParamValueArray)
         {         {
             MessageLoaderParms message(          SimpleMethodResultResponseHandler::deliverParamValue(
                 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",              cimParamValueArray);
                 "The object is not initialized.");  
   
             throw CIMException(CIM_ERR_FAILED, message);  
         }         }
  
         SimpleMethodResultResponseHandler::deliver(cimValue);      virtual void deliver(const CIMValue & cimValue);
     }  
  
 protected: protected:
     virtual String getClass(void) const      virtual String getClass(void) const;
     {  
         return(String("InvokeMethodResponseHandler"));  
     }  
   
     virtual void transfer(void)  
     {  
         CIMInvokeMethodResponseMessage & msg =  
             *static_cast<CIMInvokeMethodResponseMessage *>(getResponse());  
  
         msg.outParameters = getParamValues();      virtual void transfer(void);
  
         // ATTN-RK-20020903: Is it legal for the return value to be null?  
         // if not, then the check must be done here since deliver() works off the  
         // virtual size, which refers to out parameters!  
         msg.retValue = getReturnValue();  
     }  
 }; };
  
 typedef void (*PEGASUS_INDICATION_CALLBACK)(CIMProcessIndicationRequestMessage*);  typedef void (*PEGASUS_INDICATION_CALLBACK_T)(
       CIMProcessIndicationRequestMessage*);
  
 class EnableIndicationsResponseHandler : public OperationResponseHandler, public SimpleIndicationResponseHandler  class PEGASUS_PPM_LINKAGE EnableIndicationsResponseHandler : public OperationResponseHandler, public SimpleIndicationResponseHandler
 { {
 public: public:
     EnableIndicationsResponseHandler(     EnableIndicationsResponseHandler(
         CIMRequestMessage * request,         CIMRequestMessage * request,
         CIMResponseMessage * response,         CIMResponseMessage * response,
         CIMInstance & provider,         CIMInstance & provider,
         PEGASUS_INDICATION_CALLBACK indicationCallback)          PEGASUS_INDICATION_CALLBACK_T indicationCallback,
     : OperationResponseHandler(request, response),          PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
         _indicationCallback(indicationCallback)  
     {  
         _provider = provider;  
     }  
   
     virtual void deliver(const CIMIndication & cimIndication)  
     {  
         OperationContext context;  
   
         Array<CIMObjectPath> subscriptionInstanceNames;  
   
         context.insert(SubscriptionInstanceNamesContainer(subscriptionInstanceNames));  
   
         deliver(context, cimIndication);  
     }  
   
     virtual void deliver(const OperationContext & context, const CIMIndication & cimIndication)  
     {  
         if(cimIndication.isUninitialized())  
         {  
             MessageLoaderParms message(  
                 "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",  
                 "The object is not initialized.");  
  
             throw CIMException(CIM_ERR_FAILED, message);      virtual void deliver(const CIMIndication & cimIndication);
         }  
  
         // ATTN: temporarily convert indication to instance      virtual void deliver(const OperationContext & context, const CIMIndication & cimIndication);
         CIMInstance cimInstance(cimIndication);  
  
         //  Get list of subscription instance names from context      virtual void deliver(const Array<CIMIndication> & cimIndications);
         Array<CIMObjectPath> subscriptionInstanceNames;  
  
         try      virtual void deliver(const OperationContext & context, const Array<CIMIndication> & cimIndications);
         {  
             SubscriptionInstanceNamesContainer container =  
                 context.get(SubscriptionInstanceNamesContainer::NAME);  
   
             subscriptionInstanceNames = container.getInstanceNames();  
         }  
         catch(Exception &)  
         {  
             subscriptionInstanceNames.clear();  
         }  
   
         // l10n  
         ContentLanguages contentLangs;  
   
         try  
         {  
             // Get the Content-Language for this indication.  The provider  
             // does not have to add specify a language for the indication.  
             ContentLanguageListContainer langContainer =  
                 context.get(ContentLanguageListContainer::NAME);  
   
             contentLangs = langContainer.getLanguages();  
         }  
         catch(Exception &)  
         {  
             // The provider did not explicitly set a Content-Language for  
             // the indication.  Fall back to the lang set in this object.  
             contentLangs = getLanguages();  
         }  
         // l10n -end  
   
         // create message  
         // l10n  
         CIMProcessIndicationRequestMessage * request =  
             new CIMProcessIndicationRequestMessage(  
             XmlWriter::getNextMessageId(),  
             cimInstance.getPath().getNameSpace(),  
             cimInstance,  
             subscriptionInstanceNames,  
             _provider,  
             QueueIdStack());  // Must be filled in by the callback function  
   
         request->operationContext = context;  
   
         try  
         {  
             request->operationContext.set(ContentLanguageListContainer(contentLangs));  
         }  
         catch(Exception &)  
         {  
             request->operationContext.insert(ContentLanguageListContainer(contentLangs));  
         }  
   
         _indicationCallback(request);  
     }  
   
     virtual void deliver(const Array<CIMIndication> & cimIndications)  
     {  
         OperationContext context;  
   
         deliver(context, cimIndications);  
     }  
   
     virtual void deliver(const OperationContext & context, const Array<CIMIndication> & cimIndications)  
     {  
         for(Uint32 i = 0, n = cimIndications.size(); i < n; i++)  
         {  
             deliver(context, cimIndications[i]);  
         }  
     }  
  
 protected: protected:
     virtual String getClass(void) const      virtual String getClass(void) const;
     {  
         return(String("EnableIndicationsResponseHandler"));  
     }  
  
     virtual Boolean isAsync(void) const      virtual Boolean isAsync(void) const;
     {  
         return(false);  
     }  
  
 private: private:
     PEGASUS_INDICATION_CALLBACK _indicationCallback;      PEGASUS_INDICATION_CALLBACK_T _indicationCallback;
  
 }; };
  

Legend:
Removed from v.1.22  
changed lines
  Added in v.1.30.2.1
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2