(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.9 and 1.37

version 1.9, 2004/10/25 18:26:00 version 1.37, 2009/12/15 11:39:38
Line 1 
Line 1 
 //%2004////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development  // Licensed to The Open Group (TOG) under one or more contributor license
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.  // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;  // this work for additional information regarding copyright ownership.
 // IBM Corp.; EMC Corporation, The Open Group.  // Each contributor licenses this file to you under the OpenPegasus Open
 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;  // Source License; you may not use this file except in compliance with the
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.  // License.
 // //
 // 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
 // of this software and associated documentation files (the "Software"), to  // copy of this software and associated documentation files (the "Software"),
 // deal in the Software without restriction, including without limitation the  // to deal in the Software without restriction, including without limitation
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // sell copies of the Software, and to permit persons to whom the Software is  // and/or sell copies of the Software, and to permit persons to whom the
 // furnished to do so, subject to the following conditions:  // Software is furnished to do so, subject to the following conditions:
 // //
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  // The above copyright notice and this permission notice shall be included
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  // in all copies or substantial portions of the Software.
 // "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.  
 // //
 //==============================================================================  // 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: Chip Vincent (cvincent@us.ibm.com)  //////////////////////////////////////////////////////////////////////////
 //  
 // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company  
 //                  (carolann_graves@hp.com)  
 //              Dave Rosckes (rosckes@us.ibm.com)  
 //              Yi Zhou, Hewlett-Packard Company (yi_zhou@hp.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 41 
Line 33 
 #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/XmlWriter.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>
  
 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;
  
 public: public:
     OperationResponseHandler(CIMRequestMessage * request,      OperationResponseHandler(
                                                                                                                  CIMResponseMessage * response);          CIMRequestMessage* request,
           CIMResponseMessage* response,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
  
     virtual ~OperationResponseHandler(void);      virtual ~OperationResponseHandler();
  
     CIMRequestMessage * getRequest(void) const      CIMRequestMessage* getRequest() const;
     {  
         return(_request);  
     }  
  
     CIMResponseMessage * getResponse(void) const      CIMResponseMessage* getResponse() 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:      virtual void setCIMException(const CIMException& cimException);
  
   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() const { return true; }      virtual Boolean isAsync() const;
  
                 // 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() {}      virtual void transfer();
  
                 // validate whatever is necessary before the transfer                 // validate whatever is necessary before the transfer
                 virtual void validate() {}      virtual void validate();
  
           virtual const String& getClass() const      virtual String getClass() const;
           {  
                         static const String n("OperationResponseHandler");  
                         return n;  
                 }  
  
         Uint32 getResponseObjectTotal() const { return _responseObjectTotal; }      Uint32 getResponseObjectTotal() const;
  
                 // 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() const { return _responseMessageTotal; }      Uint32 getResponseMessageTotal() const;
  
                 Uint32 getResponseObjectThreshold() const { return _responseObjectThreshold; }      Uint32 getResponseObjectThreshold() const;
  
     CIMRequestMessage * _request;     CIMRequestMessage * _request;
     CIMResponseMessage * _response;     CIMResponseMessage * _response;
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T _responseChunkCallback;
  
 private: private:
                 Uint32 _responseObjectTotal;                 Uint32 _responseObjectTotal;
                 Uint32 _responseMessageTotal;                 Uint32 _responseMessageTotal;
                 Uint32 _responseObjectThreshold;                 Uint32 _responseObjectThreshold;
 };  
   
   
 /* ------------------------------------------------------------------------- */  
 /* operation specific response handlers                                      */  
 /* ------------------------------------------------------------------------- */  
  
 #define PEGASUS_RESPONSE_HANDLER_DERIVED_CONSTRUCT(c, b)                      \  };
 c ## ResponseHandler(CIM ## c ## RequestMessage *request,                     \  
                                  CIM ## c ## ResponseMessage *response)                   \  
 : OperationResponseHandler(request, response) {}  
   
 #define PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(c, b)                           \  
 PEGASUS_RESPONSE_HANDLER_DERIVED_CONSTRUCT(c, b)                              \  
 virtual const String& getClass() const                                        \  
 { static const String n(#c "ResponseHandler"); return n; }  
  
 class GetInstanceResponseHandler:  public OperationResponseHandler, public SimpleInstanceResponseHandler  class PEGASUS_PPM_LINKAGE GetInstanceResponseHandler :
       public OperationResponseHandler, public SimpleInstanceResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(GetInstance, SimpleInstance);      GetInstanceResponseHandler(
           CIMGetInstanceRequestMessage* request,
           CIMGetInstanceResponseMessage* response,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
  
         virtual void transfer()      virtual void deliver(const CIMInstance& cimInstance);
       virtual void deliver(const Array<CIMInstance>& cimInstanceArray)
         {         {
                 if (size() > 0)          SimpleInstanceResponseHandler::deliver(cimInstanceArray);
                 {  
                         CIMGetInstanceResponseMessage &msg =  
                                 *static_cast<CIMGetInstanceResponseMessage *>(getResponse());  
                         msg.cimInstance = getObjects()[0];  
                 }  
         }         }
       virtual void deliver(const SCMOInstance& cimInstance);
   
       virtual void complete();
   
   protected:
       virtual String getClass() const;
   
       virtual void transfer();
   
       virtual void validate();
   
   private:
       ObjectNormalizer _normalizer;
  
         virtual void validate()  
         {  
                 if (getResponseObjectTotal() == 0)  
                 {  
                         // error? provider claims success,  
                         // but did not deliver an instance.  
                         setStatus(CIM_ERR_NOT_FOUND);  
                 }  
         }  
 }; };
  
 class EnumerateInstancesResponseHandler : public OperationResponseHandler, public SimpleInstanceResponseHandler  class PEGASUS_PPM_LINKAGE EnumerateInstancesResponseHandler :
       public OperationResponseHandler, public SimpleInstanceResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(EnumerateInstances, SimpleInstance);      EnumerateInstancesResponseHandler(
           CIMEnumerateInstancesRequestMessage* request,
           CIMEnumerateInstancesResponseMessage* response,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
  
         virtual void transfer()      virtual void deliver(const CIMInstance& cimInstance);
       virtual void deliver(const Array<CIMInstance>& cimInstanceArray)
         {         {
                 CIMEnumerateInstancesResponseMessage &msg =          SimpleInstanceResponseHandler::deliver(cimInstanceArray);
                         *static_cast<CIMEnumerateInstancesResponseMessage *>(getResponse());  
                 msg.cimNamedInstances = getObjects();  
         }         }
       virtual void deliver(const SCMOInstance& scmoInstance);
   
   protected:
       virtual String getClass() const;
   
       virtual void transfer();
   
   private:
       ObjectNormalizer _normalizer;
   
 }; };
  
 class EnumerateInstanceNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler  class PEGASUS_PPM_LINKAGE EnumerateInstanceNamesResponseHandler :
       public OperationResponseHandler, public SimpleObjectPathResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(EnumerateInstanceNames, SimpleObjectPath);      EnumerateInstanceNamesResponseHandler(
           CIMEnumerateInstanceNamesRequestMessage* request,
           CIMEnumerateInstanceNamesResponseMessage* response,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
  
         virtual void transfer()      virtual void deliver(const CIMObjectPath& cimObjectPath);
       virtual void deliver(const Array<CIMObjectPath>& cimObjectPathArray)
         {         {
                 CIMEnumerateInstanceNamesResponseMessage &msg =          SimpleObjectPathResponseHandler::deliver(cimObjectPathArray);
                         *static_cast<CIMEnumerateInstanceNamesResponseMessage *>(getResponse());  
                 msg.instanceNames = getObjects();  
         }         }
       virtual void deliver(const SCMOInstance& scmoObjectPath);
   
   protected:
       virtual String getClass() const;
   
       virtual void transfer();
   
   private:
       ObjectNormalizer _normalizer;
   
 }; };
  
 class CreateInstanceResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler  class PEGASUS_PPM_LINKAGE CreateInstanceResponseHandler :
       public OperationResponseHandler, public SimpleObjectPathResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(CreateInstance, SimpleObjectPath);      CreateInstanceResponseHandler(
         // ATTN: is it an error to not return instance name?          CIMCreateInstanceRequestMessage* request,
 #if 0          CIMCreateInstanceResponseMessage* response,
         virtual void validate()          PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
         {  
                 if (getResponseObjectTotal() == 0)  
                         setStatus(CIM_ERR_NOT_FOUND);  
         }  
 #endif  
  
         virtual void transfer()      virtual void deliver(const CIMObjectPath& cimObjectPath);
         {      virtual void deliver(const Array<CIMObjectPath>& cimObjectPathArray)
                 if (size() > 0)  
                 {                 {
                         CIMCreateInstanceResponseMessage &msg =          SimpleObjectPathResponseHandler::deliver(cimObjectPathArray);
                                 *static_cast<CIMCreateInstanceResponseMessage *>(getResponse());  
                         msg.instanceName = getObjects()[0];  
                 }  
         }         }
   
       virtual void complete();
   
   protected:
       virtual String getClass() const;
   
       virtual void transfer();
   
 }; };
  
 class ModifyInstanceResponseHandler : public OperationResponseHandler, public SimpleResponseHandler  class PEGASUS_PPM_LINKAGE ModifyInstanceResponseHandler :
       public OperationResponseHandler, public SimpleResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(ModifyInstance, Simple);      ModifyInstanceResponseHandler(
           CIMModifyInstanceRequestMessage* request,
           CIMModifyInstanceResponseMessage* response,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
   
   protected:
       virtual String getClass() const;
   
 }; };
  
 class DeleteInstanceResponseHandler : public OperationResponseHandler, public SimpleResponseHandler  class PEGASUS_PPM_LINKAGE DeleteInstanceResponseHandler :
       public OperationResponseHandler, public SimpleResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(DeleteInstance, Simple);      DeleteInstanceResponseHandler(
           CIMDeleteInstanceRequestMessage* request,
           CIMDeleteInstanceResponseMessage* response,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
   
   protected:
       virtual String getClass() const;
   
 }; };
  
 class GetPropertyResponseHandler : public OperationResponseHandler, public SimpleValueResponseHandler  class PEGASUS_PPM_LINKAGE GetPropertyResponseHandler :
       public OperationResponseHandler, public SimpleValueResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(GetProperty, SimpleValue);      GetPropertyResponseHandler(
           CIMGetPropertyRequestMessage* request,
           CIMGetPropertyResponseMessage* response,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
  
         virtual void transfer()      virtual void deliver(const CIMValue& cimValue);
       virtual void deliver(const Array<CIMValue>& cimValueArray)
         {         {
                 if (size() > 0)          SimpleValueResponseHandler::deliver(cimValueArray);
                 {  
                         CIMGetPropertyResponseMessage &msg =  
                                 *static_cast<CIMGetPropertyResponseMessage *>(getResponse());  
                         msg.value = getObjects()[0];  
                 }  
         }         }
  
         virtual void validate()  protected:
         {      virtual String getClass() const;
                 // error? provider claims success,  
                 // but did not deliver an instance.      virtual void transfer();
                 if (getResponseObjectTotal() == 0)  
                         setStatus(CIM_ERR_NOT_FOUND);      virtual void validate();
         }  
 };  
  
 class SetPropertyResponseHandler : public OperationResponseHandler, public SimpleResponseHandler  
 {  
 public:  
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(SetProperty, Simple);  
 }; };
  
 class ExecQueryResponseHandler : public OperationResponseHandler, public SimpleInstance2ObjectResponseHandler  class PEGASUS_PPM_LINKAGE SetPropertyResponseHandler :
       public OperationResponseHandler, public SimpleResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(ExecQuery, SimpleInstance2Object);      SetPropertyResponseHandler(
           CIMSetPropertyRequestMessage* request,
           CIMSetPropertyResponseMessage* response,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
  
         virtual void transfer()  protected:
         {      virtual String getClass() const;
                 CIMExecQueryResponseMessage &msg = *  
                         static_cast<CIMExecQueryResponseMessage *>(getResponse());  
                 msg.cimObjects = getObjects();  
         }  
  
         // this handler will not send async but sync  
         virtual Boolean isAsync() const { return false; }  
 }; };
  
 class AssociatorsResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler  class PEGASUS_PPM_LINKAGE ExecQueryResponseHandler :
       public OperationResponseHandler,
       public SimpleInstance2ObjectResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(Associators, SimpleObject);      ExecQueryResponseHandler(
           CIMExecQueryRequestMessage* request,
           CIMExecQueryResponseMessage* response,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
  
         virtual void transfer()      virtual void deliver(const CIMInstance& cimInstance);
       virtual void deliver(const Array<CIMInstance>& cimInstanceArray)
         {         {
                 CIMAssociatorsResponseMessage &msg =          SimpleInstance2ObjectResponseHandler::deliver(cimInstanceArray);
                         *static_cast<CIMAssociatorsResponseMessage *>(getResponse());  
                 msg.cimObjects = getObjects();  
         }         }
       virtual void deliver(const SCMOInstance& scmoInstance);
   
   protected:
       virtual String getClass() const;
   
       virtual void transfer();
   
       virtual Boolean isAsync() const;
   
 }; };
  
 class AssociatorNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler  class PEGASUS_PPM_LINKAGE AssociatorsResponseHandler :
       public OperationResponseHandler, public SimpleObjectResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(AssociatorNames, SimpleObjectPath);      AssociatorsResponseHandler(
         virtual void transfer()          CIMAssociatorsRequestMessage* request,
           CIMAssociatorsResponseMessage* response,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
   
       virtual void deliver(const CIMObject& cimObject);
       virtual void deliver(const CIMInstance& cimInstance);
       virtual void deliver(const Array<CIMObject>& cimObjectArray)
         {         {
                 CIMAssociatorNamesResponseMessage &msg =          SimpleObjectResponseHandler::deliver(cimObjectArray);
                         *static_cast<CIMAssociatorNamesResponseMessage *>(getResponse());  
                 msg.objectNames = getObjects();  
         }         }
       virtual void deliver(const SCMOInstance& scmoObject);
   
   protected:
       virtual String getClass() const;
   
       virtual void transfer();
   
 }; };
  
 class ReferencesResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler  class PEGASUS_PPM_LINKAGE AssociatorNamesResponseHandler :
       public OperationResponseHandler, public SimpleObjectPathResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(References, SimpleObject);      AssociatorNamesResponseHandler(
         virtual void transfer()          CIMAssociatorNamesRequestMessage* request,
           CIMAssociatorNamesResponseMessage* response,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
   
       virtual void deliver(const CIMObjectPath& cimObjectPath);
       virtual void deliver(const Array<CIMObjectPath>& cimObjectPathArray)
         {         {
                 CIMReferencesResponseMessage &msg =          SimpleObjectPathResponseHandler::deliver(cimObjectPathArray);
                         *static_cast<CIMReferencesResponseMessage *>(getResponse());  
                 msg.cimObjects = getObjects();  
         }         }
       virtual void deliver(const SCMOInstance& scmoObjectPath);
   
   protected:
       virtual String getClass() const;
   
       virtual void transfer();
   
 }; };
  
 class ReferenceNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler  class PEGASUS_PPM_LINKAGE ReferencesResponseHandler :
       public OperationResponseHandler, public SimpleObjectResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(ReferenceNames, SimpleObjectPath);      ReferencesResponseHandler(
         virtual void transfer()          CIMReferencesRequestMessage* request,
           CIMReferencesResponseMessage* response,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
   
       virtual void deliver(const CIMObject& cimObject);
       virtual void deliver(const Array<CIMObject>& cimObjectArray)
         {         {
                 CIMReferenceNamesResponseMessage &msg =          SimpleObjectResponseHandler::deliver(cimObjectArray);
                         *static_cast<CIMReferenceNamesResponseMessage *>(getResponse());  
                 msg.objectNames = getObjects();  
         }         }
       virtual void deliver(const SCMOInstance& scmoObject);
   
   protected:
       virtual String getClass() const;
   
       virtual void transfer();
   
 }; };
  
 class InvokeMethodResponseHandler : public OperationResponseHandler, public SimpleMethodResultResponseHandler  class PEGASUS_PPM_LINKAGE ReferenceNamesResponseHandler :
       public OperationResponseHandler, public SimpleObjectPathResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(InvokeMethod, SimpleMethodResult);      ReferenceNamesResponseHandler(
           CIMReferenceNamesRequestMessage* request,
           CIMReferenceNamesResponseMessage* response,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
  
         virtual void transfer()      virtual void deliver(const CIMObjectPath& cimObjectPath);
       virtual void deliver(const Array<CIMObjectPath>& cimObjectPathArray)
         {         {
                 CIMInvokeMethodResponseMessage &msg =          SimpleObjectPathResponseHandler::deliver(cimObjectPathArray);
                         *static_cast<CIMInvokeMethodResponseMessage *>(getResponse());      }
                 msg.outParameters = getParamValues();      virtual void deliver(const SCMOInstance& scmoObjectPath);
   
   protected:
       virtual String getClass() const;
  
                 // ATTN-RK-20020903: Is it legal for the return value to be null?      virtual void transfer();
                 // 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*);  class PEGASUS_PPM_LINKAGE InvokeMethodResponseHandler :
       public OperationResponseHandler, public SimpleMethodResultResponseHandler
 class EnableIndicationsResponseHandler : public OperationResponseHandler, public SimpleIndicationResponseHandler  
 { {
 public: public:
       InvokeMethodResponseHandler(
           CIMInvokeMethodRequestMessage* request,
           CIMInvokeMethodResponseMessage* response,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
  
         // our own contructor is used, not the default one in the macro      virtual void deliverParamValue(const CIMParamValue& cimParamValue);
 #undef PEGASUS_RESPONSE_HANDLER_DERIVED_CONSTRUCT      virtual void deliverParamValue(
 #define PEGASUS_RESPONSE_HANDLER_DERIVED_CONSTRUCT(c,b)          const Array<CIMParamValue>& cimParamValueArray)
   
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(EnableIndications, SimpleIndication);  
   
         EnableIndicationsResponseHandler  
         (CIMEnableIndicationsRequestMessage * request,  
          CIMEnableIndicationsResponseMessage * response,  
          CIMInstance & provider,  
          PEGASUS_INDICATION_CALLBACK indicationCallback)  
     : OperationResponseHandler(request, response),  
                         _request_copy(*request),  
                         _response_copy(*response),  
                         _indicationCallback(indicationCallback)  
         {         {
                 _provider = provider;          SimpleMethodResultResponseHandler::deliverParamValue(
               cimParamValueArray);
         }         }
  
         // this handler will not send async but sync      virtual void deliver(const CIMValue& cimValue);
         virtual Boolean isAsync() const { return false; }  
  
         virtual void deliver(const CIMIndication & cimIndication)  protected:
         {      virtual String getClass() const;
                 OperationContext context;  
                 Array<CIMObjectPath> subscriptionInstanceNames;  
                 context.insert(SubscriptionInstanceNamesContainer(subscriptionInstanceNames));  
                 deliver(context, cimIndication);  
         }  
  
         virtual void deliver(const OperationContext & context, const CIMIndication & cimIndication)      virtual void transfer();
         {  
                 // ATTN: temporarily convert indication to instance  
                 CIMInstance cimInstance(cimIndication);  
  
                 //  };
                 //  Get list of subscription instance names from context  
                 //  
                 Array<CIMObjectPath> subscriptionInstanceNames;  
                 try  
                 {  
                         SubscriptionInstanceNamesContainer container = context.get  
                                 (SubscriptionInstanceNamesContainer::NAME);  
                         subscriptionInstanceNames =     container.getInstanceNames();  
                 }  
                 catch (Exception&)  
                 {  
                         subscriptionInstanceNames.clear();  
                 }  
  
                 // l10n  typedef void (*PEGASUS_INDICATION_CALLBACK_T)(
                 ContentLanguages contentLangs;      CIMProcessIndicationRequestMessage*);
                 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();  class PEGASUS_PPM_LINKAGE EnableIndicationsResponseHandler :
                 }      public OperationResponseHandler, public SimpleIndicationResponseHandler
                 catch (Exception&)  
                 {                 {
                         // The provider did not explicitly set a Content-Language for  public:
                         // the indication.  Fall back to the lang set in this object.      EnableIndicationsResponseHandler(
                         contentLangs = getLanguages();          CIMRequestMessage* request,
                 }          CIMResponseMessage* response,
                 // l10n -end          const CIMInstance& provider,
           PEGASUS_INDICATION_CALLBACK_T indicationCallback,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback);
  
                 // create message      virtual void deliver(const CIMIndication& cimIndication);
                 // 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;      virtual void deliver(
                 try          const OperationContext& context,
                 {          const CIMIndication& cimIndication);
                         request->operationContext.set(ContentLanguageListContainer(contentLangs));  
                 }  
                 catch(const Exception &)  
                 {  
                         request->operationContext.insert(ContentLanguageListContainer(contentLangs));  
                 }  
  
                 _indicationCallback(request);      virtual void deliver(const Array<CIMIndication>& cimIndications);
         }  
  
         virtual void deliver(const Array<CIMIndication> & cimIndications)      virtual void deliver(
         {          const OperationContext& context,
                 OperationContext context;          const Array<CIMIndication>& cimIndications);
  
                 deliver(context, cimIndications);  protected:
         }      virtual String getClass() const;
  
         virtual void deliver(const OperationContext & context, const Array<CIMIndication> & cimIndications)      virtual Boolean isAsync() const;
         {  
                 for(Uint32 i = 0, n = cimIndications.size(); i < n; i++)  
                 {  
                         deliver(context, cimIndications[i]);  
                 }  
         }  
  
 private: private:
         CIMEnableIndicationsRequestMessage _request_copy;      PEGASUS_INDICATION_CALLBACK_T _indicationCallback;
         CIMEnableIndicationsResponseMessage _response_copy;  
         PEGASUS_INDICATION_CALLBACK _indicationCallback;  
  
 }; };
  
 #undef PEGASUS_RESPONSE_HANDLER_DERIVED_INIT  
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  
 #endif #endif

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