(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.1.2.1 and 1.28.8.1

version 1.1.2.1, 2004/03/10 14:19:29 version 1.28.8.1, 2006/02/10 16:12:57
Line 1 
Line 1 
 //%2003////////////////////////////////////////////////////////////////////////  //%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.
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
 // IBM Corp.; EMC Corporation, The Open Group. // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // 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 25 
Line 31 
 // //
 // Author: Chip Vincent (cvincent@us.ibm.com) // Author: Chip Vincent (cvincent@us.ibm.com)
 // //
 // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company  // Modified By:
 //                  (carolann_graves@hp.com)  //      Carol Ann Krug Graves, Hewlett-Packard Company (carolann_graves@hp.com)
 //              Dave Rosckes (rosckes@us.ibm.com) //              Dave Rosckes (rosckes@us.ibm.com)
 //              Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com) //              Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.com)
 //              Adrian Schuur (schuur@de.ibm.com) //              Adrian Schuur (schuur@de.ibm.com)
   //      Seema Gupta (gseema@in.ibm.com) for PEP135
   //      Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase2
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 37 
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>
 #include <Pegasus/Common/CIMIndication.h> #include <Pegasus/Common/CIMIndication.h>
 #include <Pegasus/Common/CIMValue.h> #include <Pegasus/Common/CIMValue.h>
  
 #include <Pegasus/Common/ResponseHandler.h>  #include <Pegasus/Common/OperationContext.h>
 #include <Pegasus/Common/Logger.h>  #include <Pegasus/Common/OperationContextInternal.h>
   
   #include <Pegasus/Common/ObjectNormalizer.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>
Line 59 
Line 68 
  
 class PEGASUS_PPM_LINKAGE OperationResponseHandler class PEGASUS_PPM_LINKAGE OperationResponseHandler
 { {
       friend class SimpleResponseHandler;
   
 public: public:
     OperationResponseHandler(CIMRequestMessage * request, CIMResponseMessage * response)      OperationResponseHandler(
         : _request(request), _response(response)          CIMRequestMessage * request,
     {          CIMResponseMessage * response);
     }  
  
     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(const Uint32 code, const String & message = String::EMPTY)      virtual void setStatus(
     {          const Uint32 code,
         _response->cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(code), message);          const String & message = String::EMPTY);
     }  
  
     virtual void setStatus(const Uint32 code,      virtual void setStatus(
                                                 const ContentLanguages & langs,          const Uint32 code,
                                                 const String & message = String::EMPTY)          const ContentLanguageList & langs,
     {          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
       // async behavior because their callers cannot handle partial responses.
       virtual Boolean isAsync(void) const;
   
       // send (deliver) asynchronously
       virtual void send(Boolean isComplete);
   
       // transfer any objects from handler to response. this does not clear()
       virtual void transfer(void);
   
       // validate whatever is necessary before the transfer
       virtual void validate(void);
   
       virtual String getClass(void) const;
   
       Uint32 getResponseObjectTotal(void) const;
   
       // there can be many objects per message (or none at all - i.e complete())
       Uint32 getResponseMessageTotal(void) const;
   
       Uint32 getResponseObjectThreshold(void) const;
   
     CIMRequestMessage * _request;     CIMRequestMessage * _request;
     CIMResponseMessage * _response;     CIMResponseMessage * _response;
  
 };  private:
       Uint32 _responseObjectTotal;
       Uint32 _responseMessageTotal;
       Uint32 _responseObjectThreshold;
  
 /* ------------------------------------------------------------------------- */  };
 /* operation specific response handlers                                      */  
 /* ------------------------------------------------------------------------- */  
  
 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)  
       virtual void deliver(const CIMInstance & cimInstance);
       virtual void deliver(const Array<CIMInstance> & cimInstanceArray)
     {     {
           SimpleInstanceResponseHandler::deliver(cimInstanceArray);
     }     }
  
     virtual void complete()      virtual void complete(void);
     {  
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,  
                     "OperationResponseHandler: complete()");  
  
         if(getObjects().size() == 0)  protected:
         {      virtual String getClass(void) const;
             // error? provider claims success,  
             // but did not deliver an instance.  
             setStatus(CIM_ERR_NOT_FOUND);  
  
             return;      virtual void transfer(void);
         }  
  
         static_cast<CIMGetInstanceResponseMessage *>(      virtual void validate(void);
             getResponse())->cimInstance = getObjects()[0];  
   private:
       ObjectNormalizer _normalizer;
  
                 // l10n  
                 getResponse()->contentLanguages = getLanguages();  
     }  
 }; };
  
 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)  
       virtual void deliver(const CIMInstance & cimInstance);
       virtual void deliver(const Array<CIMInstance> & cimInstanceArray)
     {     {
           SimpleInstanceResponseHandler::deliver(cimInstanceArray);
     }     }
  
     virtual void complete()  protected:
     {      virtual String getClass(void) const;
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,  
                     "OperationResponseHandler: complete()");  
  
         static_cast<CIMEnumerateInstancesResponseMessage *>(      virtual void transfer(void);
             getResponse())->cimNamedInstances = getObjects();  
  
                 // l10n  private:
                 getResponse()->contentLanguages = getLanguages();      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)  
       virtual void deliver(const CIMObjectPath & cimObjectPath);
       virtual void deliver(const Array<CIMObjectPath> & cimObjectPathArray)
     {     {
           SimpleObjectPathResponseHandler::deliver(cimObjectPathArray);
     }     }
  
     virtual void complete()  protected:
     {      virtual String getClass(void) const;
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,  
                     "OperationResponseHandler: complete()");  
  
         static_cast<CIMEnumerateInstanceNamesResponseMessage *>(      virtual void transfer(void);
             getResponse())->instanceNames = getObjects();  
  
         // l10n  private:
         getResponse()->contentLanguages = getLanguages();      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)  
     {  
     }  
   
     virtual void complete()  
     {  
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,  
                     "OperationResponseHandler: complete()");  
  
         if(getObjects().size() == 0)      virtual void deliver(const CIMObjectPath & cimObjectPath);
       virtual void deliver(const Array<CIMObjectPath> & cimObjectPathArray)
         {         {
             // ATTN: is it an error to not return instance name?          SimpleObjectPathResponseHandler::deliver(cimObjectPathArray);
             return;  
         }         }
  
         static_cast<CIMCreateInstanceResponseMessage *>(      virtual void complete(void);
             getResponse())->instanceName = getObjects()[0];  
  
                 // l10n  protected:
                 getResponse()->contentLanguages = getLanguages();      virtual String getClass(void) const;
     }  
       virtual void transfer(void);
  
 }; };
  
 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)  
     {  protected:
     }      virtual String getClass(void) const;
  
 }; };
  
 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)  
     {  protected:
     }      virtual String getClass(void) const;
  
 }; };
  
 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)  
     {  
     }  
  
     virtual void complete()      virtual void deliver(const CIMValue & cimValue);
       virtual void deliver(const Array<CIMValue> & cimValueArray)
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,          SimpleValueResponseHandler::deliver(cimValueArray);
                     "OperationResponseHandler: complete()");      }
  
         if(getObjects().size() == 0)  protected:
         {      virtual String getClass(void) const;
             // error? provider claims success,  
             // but did not deliver an instance.  
             setStatus(CIM_ERR_NOT_FOUND);  
  
             return;      virtual void transfer(void);
         }  
  
         static_cast<CIMGetPropertyResponseMessage *>(      virtual void validate(void);
             getResponse())->value = getObjects()[0];  
  
                 // l10n  
                 getResponse()->contentLanguages = getLanguages();  
     }  
 }; };
  
 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)  
     {  protected:
     }      virtual String getClass(void) const;
  
 }; };
  
 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)  
       virtual void deliver(const CIMInstance & cimInstance);
       virtual void deliver(const Array<CIMInstance> & cimInstanceArray)
     {     {
           SimpleInstance2ObjectResponseHandler::deliver(cimInstanceArray);
     }     }
  
     virtual void complete()  protected:
     {      virtual String getClass(void) const;
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,  
                     "OperationResponseHandler: complete()");  
  
         static_cast<CIMExecQueryResponseMessage *>(      virtual void transfer(void);
             getResponse())->cimObjects = getObjects();  
  
         // l10n      virtual Boolean isAsync(void) const;
         getResponse()->contentLanguages = getLanguages();  
     }  
  
 }; };
  
   class PEGASUS_PPM_LINKAGE AssociatorsResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler
 class AssociatorsResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler  
 { {
 public: public:
     AssociatorsResponseHandler(     AssociatorsResponseHandler(
         CIMAssociatorsRequestMessage * request,         CIMAssociatorsRequestMessage * request,
         CIMAssociatorsResponseMessage * response)          CIMAssociatorsResponseMessage * response);
     : OperationResponseHandler(request, response)  
     {  
     }  
  
     virtual void complete()      virtual void deliver(const CIMObject & cimObject);
       virtual void deliver(const Array<CIMObject> & cimObjectArray)
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,          SimpleObjectResponseHandler::deliver(cimObjectArray);
                 "OperationResponseHandler: complete()");      }
  
         static_cast<CIMAssociatorsResponseMessage *>(  protected:
             getResponse())->cimObjects = getObjects();      virtual String getClass(void) const;
  
                 // l10n      virtual void transfer(void);
                 getResponse()->contentLanguages = getLanguages();  
     }  
  
 }; };
  
 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)  
     {  
     }  
  
     virtual void complete()      virtual void deliver(const CIMObjectPath & cimObjectPath);
       virtual void deliver(const Array<CIMObjectPath> & cimObjectPathArray)
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,          SimpleObjectPathResponseHandler::deliver(cimObjectPathArray);
                     "OperationResponseHandler: complete()");      }
  
         static_cast<CIMAssociatorNamesResponseMessage *>(  protected:
             getResponse())->objectNames.appendArray(getObjects());      virtual String getClass(void) const;
  
                 // l10n      virtual void transfer(void);
                 getResponse()->contentLanguages = getLanguages();  
     }  
  
 }; };
  
 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)  
     {  
     }  
  
     virtual void complete()      virtual void deliver(const CIMObject & cimObject);
       virtual void deliver(const Array<CIMObject> & cimObjectArray)
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,          SimpleObjectResponseHandler::deliver(cimObjectArray);
                     "OperationResponseHandler: complete()");      }
  
         static_cast<CIMReferencesResponseMessage *>(  protected:
             getResponse())->cimObjects = getObjects();      virtual String getClass(void) const;
  
                 // l10n      virtual void transfer(void);
                 getResponse()->contentLanguages = getLanguages();  
     }  
  
 }; };
  
 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)  
     {  
     }  
  
     virtual void complete()      virtual void deliver(const CIMObjectPath & cimObjectPath);
       virtual void deliver(const Array<CIMObjectPath> & cimObjectPathArray)
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,          SimpleObjectPathResponseHandler::deliver(cimObjectPathArray);
                     "OperationResponseHandler: complete()");      }
  
         static_cast<CIMReferenceNamesResponseMessage *>(  protected:
             getResponse())->objectNames.appendArray(getObjects());      virtual String getClass(void) const;
  
                 // l10n      virtual void transfer(void);
                 getResponse()->contentLanguages = getLanguages();  
     }  
  
 }; };
  
 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)  
     {  
     }  
  
     virtual void complete()      virtual void deliverParamValue(const CIMParamValue & cimParamValue);
       virtual void deliverParamValue(
           const Array<CIMParamValue> & cimParamValueArray)
     {     {
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,          SimpleMethodResultResponseHandler::deliverParamValue(
             "OperationResponseHandler: complete()");              cimParamValueArray);
       }
         // ATTN-RK-20020903: Is it legal for the return value to be null?  
         //if(getReturnValue().isNull())  
         //{  
             // ATTN: error? provider claims success, but did not deliver a CIMValue.  
         //    return;  
         //}  
  
         static_cast<CIMInvokeMethodResponseMessage *>(      virtual void deliver(const CIMValue & cimValue);
             getResponse())->outParameters = getParamValues();  
  
         static_cast<CIMInvokeMethodResponseMessage *>(  protected:
             getResponse())->retValue = getReturnValue();      virtual String getClass(void) const;
  
                 // l10n      virtual void transfer(void);
                 getResponse()->contentLanguages = getLanguages();  
     }  
  
 }; };
  
   typedef void (*PEGASUS_INDICATION_CALLBACK)(CIMProcessIndicationRequestMessage*);
  
 class EnableIndicationsResponseHandler : public OperationResponseHandler, public SimpleIndicationResponseHandler  class PEGASUS_PPM_LINKAGE EnableIndicationsResponseHandler : public OperationResponseHandler, public SimpleIndicationResponseHandler
 { {
 public: public:
     EnableIndicationsResponseHandler(     EnableIndicationsResponseHandler(
         CIMEnableIndicationsRequestMessage * request,          CIMRequestMessage * request,
         CIMEnableIndicationsResponseMessage * response,          CIMResponseMessage * response,
         CIMInstance & provider,         CIMInstance & provider,
         MessageQueueService * source,          PEGASUS_INDICATION_CALLBACK indicationCallback);
         MessageQueueService * target = 0)  
     : OperationResponseHandler(request, response),  
         _source(source),  
         _target(target),  
         _request_copy(*request),  
         _response_copy(*response)  
     {  
         PEGASUS_ASSERT(_source != 0);  
   
         _provider = provider;  
   
         // get indication service  
         if(_target == 0)  
         {  
             Array<Uint32> serviceIds;  
   
             _source->find_services(PEGASUS_QUEUENAME_INDICATIONSERVICE, 0, 0, &serviceIds);  
   
             PEGASUS_ASSERT(serviceIds.size() != 0);  
   
             _target = dynamic_cast<MessageQueueService *>(MessageQueue::lookup(serviceIds[0]));  
   
             PEGASUS_ASSERT(_target != 0);  
         }  
     }  
   
     virtual void deliver(const CIMIndication & cimIndication)  
     {  
         OperationContext context;  
   
         Array<CIMObjectPath> subscriptionInstanceNames;  
  
         context.insert(SubscriptionInstanceNamesContainer      virtual void deliver(const CIMIndication & cimIndication);
             (subscriptionInstanceNames));  
  
         deliver(context, cimIndication);      virtual void deliver(const OperationContext & context, const CIMIndication & cimIndication);
     }  
  
     virtual void deliver(const OperationContext & context, const CIMIndication & cimIndication)      virtual void deliver(const Array<CIMIndication> & cimIndications);
     {  
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,  
                     "OperationResponseHandler: deliver()");  
         // ATTN: temporarily convert indication to instance  
         CIMInstance cimInstance(cimIndication);  
  
         //      virtual void deliver(const OperationContext & context, const Array<CIMIndication> & cimIndications);
         //  Get list of subscription instance names from context  
         //  
         Array<CIMObjectPath> subscriptionInstanceNames;  
         try  
         {  
             SubscriptionInstanceNamesContainer container = context.get  
                  (SubscriptionInstanceNamesContainer::NAME);  
   
             subscriptionInstanceNames =  
                 container.getInstanceNames();  
         }  
         catch (Exception& e)  
         {  
             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 & e)  
                 {  
                         // 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(  
              _request_copy.messageId,  
             cimInstance.getPath().getNameSpace(),  
             cimInstance,  
             subscriptionInstanceNames,  
             _provider,  
             QueueIdStack(_target->getQueueId(), _source->getQueueId()),  
             contentLangs);  
         request->operationContext = context;  
   
         // send message  
         // <<< Wed Apr 10 21:04:00 2002 mdd >>>  
         // AsyncOpNode * op = _source->get_op();  
   
         AsyncLegacyOperationStart * asyncRequest =  
             new AsyncLegacyOperationStart(  
             _source->get_next_xid(),  
             0,  
             _target->getQueueId(),  
             request,  
             _target->getQueueId());  
   
         PEGASUS_ASSERT(asyncRequest != 0);  
   
         //AsyncReply * asyncReply = _source->SendWait(asyncRequest);  
         // <<< Wed Apr 10 21:04:50 2002 mdd >>>  
         _source->SendForget(asyncRequest);  
         //PEGASUS_ASSERT(asyncReply != 0);  
   
         //  Chip - receiver of the request should delete it  
         //delete asyncRequest;  
         // <<< Wed Apr 10 21:05:10 2002 mdd >>>  
     }  
   
     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:
     MessageQueueService * _source;      virtual String getClass(void) const;
     MessageQueueService * _target;  
       virtual Boolean isAsync(void) const;
  
 private: private:
     CIMEnableIndicationsRequestMessage _request_copy;      PEGASUS_INDICATION_CALLBACK _indicationCallback;
     CIMEnableIndicationsResponseMessage _response_copy;  
 }; };
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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