(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.10 and 1.16

version 1.10, 2005/01/10 15:55:07 version 1.16, 2005/02/03 18:35:05
Line 27 
Line 27 
 // //
 // 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)
Line 52 
Line 52 
 #include <Pegasus/Common/CIMIndication.h> #include <Pegasus/Common/CIMIndication.h>
 #include <Pegasus/Common/CIMValue.h> #include <Pegasus/Common/CIMValue.h>
  
   #include <Pegasus/Common/OperationContext.h>
   #include <Pegasus/Common/OperationContextInternal.h>
   
   #include <Pegasus/Common/ObjectNormalizer.h>
 #include <Pegasus/Common/ResponseHandler.h> #include <Pegasus/Common/ResponseHandler.h>
 #include <Pegasus/Common/Logger.h> #include <Pegasus/Common/Logger.h>
 #include <Pegasus/Common/XmlWriter.h> #include <Pegasus/Common/XmlWriter.h>
Line 66 
Line 70 
         friend class SimpleResponseHandler;         friend class SimpleResponseHandler;
  
 public: public:
     OperationResponseHandler(CIMRequestMessage * request,      OperationResponseHandler(
           CIMRequestMessage * request,
                                                                                                                  CIMResponseMessage * response);                                                                                                                  CIMResponseMessage * response);
  
     virtual ~OperationResponseHandler(void);     virtual ~OperationResponseHandler(void);
Line 81 
Line 86 
         return(_response);         return(_response);
     }     }
  
     virtual void setStatus(const Uint32 code, const String & message = String::EMPTY)      virtual void setStatus(
           const Uint32 code,
           const String & message = String::EMPTY)
     {     {
         _response->cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(code), message);         _response->cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(code), message);
     }     }
  
     virtual void setStatus(const Uint32 code,      virtual void setStatus(
           const Uint32 code,
                                                 const ContentLanguages & langs,                                                 const ContentLanguages & langs,
                                                 const String & message = String::EMPTY)                                                 const String & message = String::EMPTY)
     {     {
         _response->cimException = PEGASUS_CIM_EXCEPTION_LANG(          _response->cimException =
               PEGASUS_CIM_EXCEPTION_LANG(
                                                         langs,                                                         langs,
                                                         CIMStatusCode(code),                                                         CIMStatusCode(code),
                                                          message);                                                          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() const { return true; }      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() {}      virtual void transfer(void)
       {
       }
  
                 // validate whatever is necessary before the transfer                 // validate whatever is necessary before the transfer
                 virtual void validate() {}      virtual void validate(void)
       {
       }
  
           virtual String getClass() const      virtual String getClass(void) const
           {           {
                         return String ("OperationResponseHandler");          return(String("OperationResponseHandler"));
                 }                 }
  
         Uint32 getResponseObjectTotal() const { return _responseObjectTotal; }      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() const { return _responseMessageTotal; }      Uint32 getResponseMessageTotal(void) const
       {
           return(_responseMessageTotal);
       }
  
                 Uint32 getResponseObjectThreshold() const { return _responseObjectThreshold; }      Uint32 getResponseObjectThreshold(void) const
       {
           return(_responseObjectThreshold);
       }
  
     CIMRequestMessage * _request;     CIMRequestMessage * _request;
     CIMResponseMessage * _response;     CIMResponseMessage * _response;
Line 130 
Line 154 
                 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 String getClass() const { return String (#c "ResponseHandler"); }  
  
 class GetInstanceResponseHandler:  public OperationResponseHandler, public SimpleInstanceResponseHandler class GetInstanceResponseHandler:  public OperationResponseHandler, public SimpleInstanceResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(GetInstance, SimpleInstance);      GetInstanceResponseHandler(
           CIMGetInstanceRequestMessage * request,
           CIMGetInstanceResponseMessage * response)
       : OperationResponseHandler(request, response)
       {
           #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->localOnly,
                   request->includeQualifiers,
                   request->includeClassOrigin);
           #endif
       }
   
       #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
       virtual void deliver(const CIMInstance & cimInstance)
       {
           // Normalize (if seeded, otherwise do nothing) and pass to subclass method for delivery.
           SimpleInstanceResponseHandler::deliver(_normalizer.processInstance(cimInstance));
       }
       #endif
  
         virtual void transfer()      virtual String getClass(void) const
       {
           return(String("GetInstanceResponseHandler"));
       }
   
       virtual void transfer(void)
         {         {
                 if (size() > 0)                 if (size() > 0)
                 {                 {
                         CIMGetInstanceResponseMessage &msg =                         CIMGetInstanceResponseMessage &msg =
                                 *static_cast<CIMGetInstanceResponseMessage *>(getResponse());                                 *static_cast<CIMGetInstanceResponseMessage *>(getResponse());
   
                         msg.cimInstance = getObjects()[0];                         msg.cimInstance = getObjects()[0];
                 }                 }
         }         }
  
         virtual void validate()      virtual void validate(void)
         {         {
                 if (getResponseObjectTotal() == 0)                 if (getResponseObjectTotal() == 0)
                 {                 {
Line 170 
Line 227 
                         setStatus(CIM_ERR_NOT_FOUND);                         setStatus(CIM_ERR_NOT_FOUND);
                 }                 }
         }         }
   
   private:
       ObjectNormalizer _normalizer;
   
 }; };
  
 class EnumerateInstancesResponseHandler : public OperationResponseHandler, public SimpleInstanceResponseHandler class EnumerateInstancesResponseHandler : public OperationResponseHandler, public SimpleInstanceResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(EnumerateInstances, SimpleInstance);      EnumerateInstancesResponseHandler(
           CIMEnumerateInstancesRequestMessage * request,
           CIMEnumerateInstancesResponseMessage * response)
       : OperationResponseHandler(request, response)
       {
           #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->localOnly,
                   request->includeQualifiers,
                   request->includeClassOrigin);
           #endif
       }
  
         virtual void transfer()      #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
       virtual void deliver(const CIMInstance & cimInstance)
       {
           // Normalize (if seeded, otherwise do nothing) and pass to subclass method for delivery.
           SimpleInstanceResponseHandler::deliver(_normalizer.processInstance(cimInstance));
       }
       #endif
   
       virtual String getClass(void) const
       {
           return(String("EnumerateInstancesResponseHandler"));
       }
   
       virtual void transfer(void)
         {         {
                 CIMEnumerateInstancesResponseMessage &msg =                 CIMEnumerateInstancesResponseMessage &msg =
                         *static_cast<CIMEnumerateInstancesResponseMessage *>(getResponse());                         *static_cast<CIMEnumerateInstancesResponseMessage *>(getResponse());
   
                 msg.cimNamedInstances = getObjects();                 msg.cimNamedInstances = getObjects();
         }         }
   
   private:
       ObjectNormalizer _normalizer;
   
 }; };
  
 class EnumerateInstanceNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler class EnumerateInstanceNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(EnumerateInstanceNames, SimpleObjectPath);      EnumerateInstanceNamesResponseHandler(
           CIMEnumerateInstanceNamesRequestMessage * request,
           CIMEnumerateInstanceNamesResponseMessage * response)
       : OperationResponseHandler(request, response)
       {
           #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,
                   false,
                   false,
                   false);
           #endif
       }
   
       #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
       virtual void deliver(const CIMObjectPath & cimObjectPath)
       {
           // Normalize (if seeded, otherwise do nothing) and pass to subclass method for delivery.
           SimpleObjectPathResponseHandler::deliver(_normalizer.processInstanceObjectPath(cimObjectPath));
       }
       #endif
   
       virtual String getClass(void) const
       {
           return(String("EnumerateInstanceNamesResponseHandler"));
       }
  
         virtual void transfer()      virtual void transfer(void)
         {         {
                 CIMEnumerateInstanceNamesResponseMessage &msg =                 CIMEnumerateInstanceNamesResponseMessage &msg =
                         *static_cast<CIMEnumerateInstanceNamesResponseMessage *>(getResponse());                         *static_cast<CIMEnumerateInstanceNamesResponseMessage *>(getResponse());
   
                 msg.instanceNames = getObjects();                 msg.instanceNames = getObjects();
         }         }
   
   private:
       ObjectNormalizer _normalizer;
   
 }; };
  
 class CreateInstanceResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler class 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,
           CIMCreateInstanceResponseMessage * response)
       : OperationResponseHandler(request, response)
       {
       }
   
       virtual String getClass(void) const
       {
           return(String("CreateInstanceResponseHandler"));
       }
   
 #if 0 #if 0
         virtual void validate()      // ATTN: is it an error to not return instance name?
       virtual void validate(void)
         {         {
                 if (getResponseObjectTotal() == 0)                 if (getResponseObjectTotal() == 0)
           {
                         setStatus(CIM_ERR_NOT_FOUND);                         setStatus(CIM_ERR_NOT_FOUND);
         }         }
       }
 #endif #endif
  
         virtual void transfer()      virtual void transfer(void)
         {         {
                 if (size() > 0)                 if (size() > 0)
                 {                 {
                         CIMCreateInstanceResponseMessage &msg =                         CIMCreateInstanceResponseMessage &msg =
                                 *static_cast<CIMCreateInstanceResponseMessage *>(getResponse());                                 *static_cast<CIMCreateInstanceResponseMessage *>(getResponse());
   
                         msg.instanceName = getObjects()[0];                         msg.instanceName = getObjects()[0];
                 }                 }
         }         }
Line 225 
Line 398 
 class ModifyInstanceResponseHandler : public OperationResponseHandler, public SimpleResponseHandler class ModifyInstanceResponseHandler : public OperationResponseHandler, public SimpleResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(ModifyInstance, Simple);      ModifyInstanceResponseHandler(
           CIMModifyInstanceRequestMessage * request,
           CIMModifyInstanceResponseMessage * response)
       : OperationResponseHandler(request, response)
       {
       }
   
       virtual String getClass(void) const
       {
           return(String("ModifyInstanceResponseHandler"));
       }
   
 }; };
  
 class DeleteInstanceResponseHandler : public OperationResponseHandler, public SimpleResponseHandler class DeleteInstanceResponseHandler : public OperationResponseHandler, public SimpleResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(DeleteInstance, Simple);      DeleteInstanceResponseHandler(
           CIMDeleteInstanceRequestMessage * request,
           CIMDeleteInstanceResponseMessage * response)
       : OperationResponseHandler(request, response)
       {
       }
   
       virtual String getClass(void) const
       {
           return(String("DeleteInstanceResponseHandler"));
       }
   
 }; };
  
 class GetPropertyResponseHandler : public OperationResponseHandler, public SimpleValueResponseHandler class GetPropertyResponseHandler : public OperationResponseHandler, public SimpleValueResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(GetProperty, SimpleValue);      GetPropertyResponseHandler(
           CIMGetPropertyRequestMessage * request,
           CIMGetPropertyResponseMessage * response)
       : OperationResponseHandler(request, response)
       {
       }
  
         virtual void transfer()      virtual String getClass(void) const
       {
           return(String("GetPropertyResponseHandler"));
       }
   
       virtual void transfer(void)
         {         {
                 if (size() > 0)                 if (size() > 0)
                 {                 {
                         CIMGetPropertyResponseMessage &msg =                         CIMGetPropertyResponseMessage &msg =
                                 *static_cast<CIMGetPropertyResponseMessage *>(getResponse());                                 *static_cast<CIMGetPropertyResponseMessage *>(getResponse());
   
                         msg.value = getObjects()[0];                         msg.value = getObjects()[0];
                 }                 }
         }         }
  
         virtual void validate()      virtual void validate(void)
         {         {
                 // error? provider claims success,                 // error? provider claims success,
                 // but did not deliver an instance.                 // but did not deliver an instance.
                 if (getResponseObjectTotal() == 0)                 if (getResponseObjectTotal() == 0)
           {
                         setStatus(CIM_ERR_NOT_FOUND);                         setStatus(CIM_ERR_NOT_FOUND);
         }         }
       }
 }; };
  
 class SetPropertyResponseHandler : public OperationResponseHandler, public SimpleResponseHandler class SetPropertyResponseHandler : public OperationResponseHandler, public SimpleResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(SetProperty, Simple);      SetPropertyResponseHandler(
           CIMSetPropertyRequestMessage * request,
           CIMSetPropertyResponseMessage * response)
       : OperationResponseHandler(request, response)
       {
       }
   
       virtual String getClass(void) const
       {
           return(String("SetPropertyResponseHandler"));
       }
   
 }; };
  
 class ExecQueryResponseHandler : public OperationResponseHandler, public SimpleInstance2ObjectResponseHandler class ExecQueryResponseHandler : public OperationResponseHandler, public SimpleInstance2ObjectResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(ExecQuery, SimpleInstance2Object);      ExecQueryResponseHandler(
           CIMExecQueryRequestMessage * request,
           CIMExecQueryResponseMessage * response)
       : OperationResponseHandler(request, response)
       {
       }
   
       virtual String getClass(void) const
       {
           return(String("ExecQueryResponseHandler"));
       }
  
         virtual void transfer()      virtual void transfer(void)
         {         {
                 CIMExecQueryResponseMessage &msg = *          CIMExecQueryResponseMessage & msg =
                         static_cast<CIMExecQueryResponseMessage *>(getResponse());              *static_cast<CIMExecQueryResponseMessage *>(getResponse());
   
                 msg.cimObjects = getObjects();                 msg.cimObjects = getObjects();
         }         }
  
         // this handler will not send async but sync      virtual Boolean isAsync(void) const
         virtual Boolean isAsync() const { return false; }      {
           return(false);
       }
 }; };
  
 class AssociatorsResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler class AssociatorsResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(Associators, SimpleObject);      AssociatorsResponseHandler(
           CIMAssociatorsRequestMessage * request,
           CIMAssociatorsResponseMessage * response)
       : OperationResponseHandler(request, response)
       {
       }
  
         virtual void transfer()      virtual String getClass(void) const
       {
           return(String("AssociatorsResponseHandler"));
       }
   
       virtual void transfer(void)
         {         {
                 CIMAssociatorsResponseMessage &msg =                 CIMAssociatorsResponseMessage &msg =
                         *static_cast<CIMAssociatorsResponseMessage *>(getResponse());                         *static_cast<CIMAssociatorsResponseMessage *>(getResponse());
   
                 msg.cimObjects = getObjects();                 msg.cimObjects = getObjects();
         }         }
 }; };
Line 296 
Line 539 
 class AssociatorNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler class AssociatorNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(AssociatorNames, SimpleObjectPath);      AssociatorNamesResponseHandler(
         virtual void transfer()          CIMAssociatorNamesRequestMessage * request,
           CIMAssociatorNamesResponseMessage * response)
       : OperationResponseHandler(request, response)
       {
       }
   
       virtual String getClass(void) const
       {
           return(String("AssociatorNamesResponseHandler"));
       }
   
       virtual void transfer(void)
         {         {
                 CIMAssociatorNamesResponseMessage &msg =                 CIMAssociatorNamesResponseMessage &msg =
                         *static_cast<CIMAssociatorNamesResponseMessage *>(getResponse());                         *static_cast<CIMAssociatorNamesResponseMessage *>(getResponse());
   
                 msg.objectNames = getObjects();                 msg.objectNames = getObjects();
         }         }
 }; };
Line 308 
Line 563 
 class ReferencesResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler class ReferencesResponseHandler : public OperationResponseHandler, public SimpleObjectResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(References, SimpleObject);      ReferencesResponseHandler(
         virtual void transfer()          CIMReferencesRequestMessage * request,
           CIMReferencesResponseMessage * response)
       : OperationResponseHandler(request, response)
       {
       }
   
       virtual String getClass(void) const
       {
           return(String("ReferencesResponseHandler"));
       }
   
       virtual void transfer(void)
         {         {
                 CIMReferencesResponseMessage &msg =                 CIMReferencesResponseMessage &msg =
                         *static_cast<CIMReferencesResponseMessage *>(getResponse());                         *static_cast<CIMReferencesResponseMessage *>(getResponse());
   
                 msg.cimObjects = getObjects();                 msg.cimObjects = getObjects();
         }         }
 }; };
Line 320 
Line 587 
 class ReferenceNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler class ReferenceNamesResponseHandler : public OperationResponseHandler, public SimpleObjectPathResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(ReferenceNames, SimpleObjectPath);      ReferenceNamesResponseHandler(
         virtual void transfer()          CIMReferenceNamesRequestMessage * request,
           CIMReferenceNamesResponseMessage * response)
       : OperationResponseHandler(request, response)
       {
       }
   
       virtual String getClass(void) const
       {
           return(String("ReferenceNamesResponseHandler"));
       }
   
       virtual void transfer(void)
         {         {
                 CIMReferenceNamesResponseMessage &msg =                 CIMReferenceNamesResponseMessage &msg =
                         *static_cast<CIMReferenceNamesResponseMessage *>(getResponse());                         *static_cast<CIMReferenceNamesResponseMessage *>(getResponse());
   
                 msg.objectNames = getObjects();                 msg.objectNames = getObjects();
         }         }
 }; };
Line 332 
Line 611 
 class InvokeMethodResponseHandler : public OperationResponseHandler, public SimpleMethodResultResponseHandler class InvokeMethodResponseHandler : public OperationResponseHandler, public SimpleMethodResultResponseHandler
 { {
 public: public:
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(InvokeMethod, SimpleMethodResult);      InvokeMethodResponseHandler(
           CIMInvokeMethodRequestMessage * request,
           CIMInvokeMethodResponseMessage * response)
       : OperationResponseHandler(request, response)
       {
       }
  
         virtual void transfer()      virtual String getClass(void) const
       {
           return(String("InvokeMethodResponseHandler"));
       }
   
       virtual void transfer(void)
         {         {
                 CIMInvokeMethodResponseMessage &msg =                 CIMInvokeMethodResponseMessage &msg =
                         *static_cast<CIMInvokeMethodResponseMessage *>(getResponse());                         *static_cast<CIMInvokeMethodResponseMessage *>(getResponse());
   
                 msg.outParameters = getParamValues();                 msg.outParameters = getParamValues();
  
                 // ATTN-RK-20020903: Is it legal for the return value to be null?                 // 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                 // if not, then the check must be done here since deliver() works off the
                 // virtual size, which refers to out parameters!                 // virtual size, which refers to out parameters!
   
                 msg.retValue = getReturnValue();                 msg.retValue = getReturnValue();
         }         }
 }; };
Line 353 
Line 642 
 class EnableIndicationsResponseHandler : public OperationResponseHandler, public SimpleIndicationResponseHandler class EnableIndicationsResponseHandler : public OperationResponseHandler, public SimpleIndicationResponseHandler
 { {
 public: public:
       EnableIndicationsResponseHandler(
         // our own contructor is used, not the default one in the macro          CIMEnableIndicationsRequestMessage * request,
 #undef PEGASUS_RESPONSE_HANDLER_DERIVED_CONSTRUCT  
 #define PEGASUS_RESPONSE_HANDLER_DERIVED_CONSTRUCT(c,b)  
   
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(EnableIndications, SimpleIndication);  
   
         EnableIndicationsResponseHandler  
         (CIMEnableIndicationsRequestMessage * request,  
          CIMEnableIndicationsResponseMessage * response,          CIMEnableIndicationsResponseMessage * response,
          CIMInstance & provider,          CIMInstance & provider,
          PEGASUS_INDICATION_CALLBACK indicationCallback)          PEGASUS_INDICATION_CALLBACK indicationCallback)
Line 373 
Line 655 
                 _provider = provider;                 _provider = provider;
         }         }
  
         // this handler will not send async but sync      virtual String getClass(void) const
         virtual Boolean isAsync() const { return false; }      {
           return(String("EnableIndicationsResponseHandler"));
       }
   
       virtual Boolean isAsync(void) const
       {
           return(false);
       }
  
         virtual void deliver(const CIMIndication & cimIndication)         virtual void deliver(const CIMIndication & cimIndication)
         {         {
                 OperationContext context;                 OperationContext context;
   
                 Array<CIMObjectPath> subscriptionInstanceNames;                 Array<CIMObjectPath> subscriptionInstanceNames;
   
                 context.insert(SubscriptionInstanceNamesContainer(subscriptionInstanceNames));                 context.insert(SubscriptionInstanceNamesContainer(subscriptionInstanceNames));
   
                 deliver(context, cimIndication);                 deliver(context, cimIndication);
         }         }
  
Line 389 
Line 681 
                 // ATTN: temporarily convert indication to instance                 // ATTN: temporarily convert indication to instance
                 CIMInstance cimInstance(cimIndication);                 CIMInstance cimInstance(cimIndication);
  
                 //  
                 //  Get list of subscription instance names from context                 //  Get list of subscription instance names from context
                 //  
                 Array<CIMObjectPath> subscriptionInstanceNames;                 Array<CIMObjectPath> subscriptionInstanceNames;
   
                 try                 try
                 {                 {
                         SubscriptionInstanceNamesContainer container = context.get              SubscriptionInstanceNamesContainer container =
                                 (SubscriptionInstanceNamesContainer::NAME);                  context.get(SubscriptionInstanceNamesContainer::NAME);
   
                         subscriptionInstanceNames =     container.getInstanceNames();                         subscriptionInstanceNames =     container.getInstanceNames();
                 }                 }
                 catch (Exception&)                 catch (Exception&)
Line 406 
Line 698 
  
                 // l10n                 // l10n
                 ContentLanguages contentLangs;                 ContentLanguages contentLangs;
   
                 try                 try
                 {                 {
                         // Get the Content-Language for this indication.  The provider                         // Get the Content-Language for this indication.  The provider
                         // does not have to add specify a language for the indication.                         // does not have to add specify a language for the indication.
                         ContentLanguageListContainer langContainer = context.get              ContentLanguageListContainer langContainer =
                                 (ContentLanguageListContainer::NAME);                  context.get(ContentLanguageListContainer::NAME);
  
                         contentLangs = langContainer.getLanguages();                         contentLangs = langContainer.getLanguages();
                 }                 }
Line 435 
Line 728 
                                                                                                                                                                                  QueueIdStack());  // Must be filled in by the callback function                                                                                                                                                                                  QueueIdStack());  // Must be filled in by the callback function
  
                 request->operationContext = context;                 request->operationContext = context;
   
                 try                 try
                 {                 {
                         request->operationContext.set(ContentLanguageListContainer(contentLangs));                         request->operationContext.set(ContentLanguageListContainer(contentLangs));
                 }                 }
                 catch(const Exception &)          catch(Exception &)
                 {                 {
                         request->operationContext.insert(ContentLanguageListContainer(contentLangs));                         request->operationContext.insert(ContentLanguageListContainer(contentLangs));
                 }                 }
Line 469 
Line 763 
  
 }; };
  
 #undef PEGASUS_RESPONSE_HANDLER_DERIVED_INIT  
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  
 #endif #endif

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