(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.22

version 1.10, 2005/01/10 15:55:07 version 1.22, 2005/03/11 01:51:56
Line 1 
Line 1 
 //%2004////////////////////////////////////////////////////////////////////////  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
Line 6 
Line 6 
 // 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.; // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software 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 27 
Line 29 
 // //
 // 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 54 
 #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 72 
         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 88 
         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 156 
                 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;
  
         virtual void transfer()          try
           {
               CachedClassDefinitionContainer container =
                   request->operationContext.get(CachedClassDefinitionContainer::NAME);
   
               cimClass = container.getClass();
   
           }
           catch(Exception &)
           {
               // Do nothing. Container is missing, which implies normalization is disabled
               // for this operation.
           }
   
           _normalizer =
               ObjectNormalizer(
                   cimClass,
                   request->includeQualifiers,
                   request->includeClassOrigin);
           #endif
       }
   
       virtual void deliver(const CIMInstance & cimInstance)
       {
           if(cimInstance.isUninitialized())
           {
               MessageLoaderParms message(
                   "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
                   "The object is not initialized.");
   
               throw CIMException(CIM_ERR_FAILED, message);
           }
   
           #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
           SimpleInstanceResponseHandler::deliver(_normalizer.processInstance(cimInstance));
           #else
           SimpleInstanceResponseHandler::deliver(cimInstance);
           #endif
       }
   
   protected:
       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 239 
                         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->includeQualifiers,
                   request->includeClassOrigin);
           #endif
       }
   
       virtual void deliver(const CIMInstance & cimInstance)
       {
           if(cimInstance.isUninitialized())
           {
               MessageLoaderParms message(
                   "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
                   "The object is not initialized.");
   
               throw CIMException(CIM_ERR_FAILED, message);
           }
   
           #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
           SimpleInstanceResponseHandler::deliver(_normalizer.processInstance(cimInstance));
           #else
           SimpleInstanceResponseHandler::deliver(cimInstance);
           #endif
       }
   
   protected:
       virtual String getClass(void) const
       {
           return(String("EnumerateInstancesResponseHandler"));
       }
  
         virtual void transfer()      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.
           }
  
         virtual void transfer()          _normalizer =
               ObjectNormalizer(
                   cimClass,
                   false,
                   false);
           #endif
       }
   
       virtual void deliver(const CIMObjectPath & cimObjectPath)
       {
           if(cimObjectPath.getClassName().isNull())
           {
               MessageLoaderParms message(
                   "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
                   "The object is not initialized.");
   
               throw CIMException(CIM_ERR_FAILED, message);
           }
   
           #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
           SimpleObjectPathResponseHandler::deliver(_normalizer.processInstanceObjectPath(cimObjectPath));
           #else
           SimpleObjectPathResponseHandler::deliver(cimObjectPath);
           #endif
       }
   
   protected:
       virtual String getClass(void) const
       {
           return(String("EnumerateInstanceNamesResponseHandler"));
       }
   
       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 void deliver(const CIMObjectPath & cimObjectPath)
       {
           if(cimObjectPath.getClassName().isNull())
           {
               MessageLoaderParms message(
                   "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
                   "The object is not initialized.");
   
               throw CIMException(CIM_ERR_FAILED, message);
           }
   
           SimpleObjectPathResponseHandler::deliver(cimObjectPath);
       }
   
   protected:
       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 445 
 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)
       {
       }
   
   protected:
       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)
       {
       }
   
   protected:
       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 deliver(const CIMValue & cimValue)
       {
           if(cimValue.isNull())
           {
               MessageLoaderParms message(
                   "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
                   "The object is not initialized.");
   
               throw CIMException(CIM_ERR_FAILED, message);
           }
   
           SimpleValueResponseHandler::deliver(cimValue);
       }
  
         virtual void transfer()  protected:
       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)
       {
       }
   
   protected:
       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 void transfer()      virtual void deliver(const CIMInstance & cimInstance)
       {
           if(cimInstance.isUninitialized())
           {
               MessageLoaderParms message(
                   "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
                   "The object is not initialized.");
   
               throw CIMException(CIM_ERR_FAILED, message);
           }
   
           SimpleInstance2ObjectResponseHandler::deliver(cimInstance);
       }
   
   protected:
       virtual String getClass(void) const
         {         {
                 CIMExecQueryResponseMessage &msg = *          return(String("ExecQueryResponseHandler"));
                         static_cast<CIMExecQueryResponseMessage *>(getResponse());      }
   
       virtual void transfer(void)
       {
           CIMExecQueryResponseMessage & msg =
               *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 void deliver(const CIMObject & cimObject)
       {
           if(cimObject.isUninitialized())
           {
               MessageLoaderParms message(
                   "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
                   "The object is not initialized.");
   
               throw CIMException(CIM_ERR_FAILED, message);
           }
   
           SimpleObjectResponseHandler::deliver(cimObject);
       }
   
   protected:
       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 633 
 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 void deliver(const CIMObjectPath & cimObjectPath)
       {
           if(cimObjectPath.getClassName().isNull())
           {
               MessageLoaderParms message(
                   "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
                   "The object is not initialized.");
   
               throw CIMException(CIM_ERR_FAILED, message);
           }
   
           SimpleObjectPathResponseHandler::deliver(cimObjectPath);
       }
   
   protected:
       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 672 
 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 void deliver(const CIMObject & cimObject)
       {
           if(cimObject.isUninitialized())
           {
               MessageLoaderParms message(
                   "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
                   "The object is not initialized.");
   
               throw CIMException(CIM_ERR_FAILED, message);
           }
   
           SimpleObjectResponseHandler::deliver(cimObject);
       }
   
   protected:
       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 711 
 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 void deliver(const CIMObjectPath & cimObjectPath)
       {
           if(cimObjectPath.getClassName().isNull())
           {
               MessageLoaderParms message(
                   "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
                   "The object is not initialized.");
   
               throw CIMException(CIM_ERR_FAILED, message);
           }
   
           SimpleObjectPathResponseHandler::deliver(cimObjectPath);
       }
   
   protected:
       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 750 
 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 void deliverParamValue(const CIMParamValue & cimParamValue)
       {
           if(cimParamValue.isUninitialized())
           {
               MessageLoaderParms message(
                   "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
                   "The object is not initialized.");
   
               throw CIMException(CIM_ERR_FAILED, message);
           }
   
           SimpleMethodResultResponseHandler::deliverParamValue(cimParamValue);
       }
   
       virtual void deliver(const CIMValue & cimValue)
       {
           if(cimValue.isNull())
           {
               MessageLoaderParms message(
                   "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
                   "The object is not initialized.");
   
               throw CIMException(CIM_ERR_FAILED, message);
           }
   
           SimpleMethodResultResponseHandler::deliver(cimValue);
       }
   
   protected:
       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 810 
 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          CIMRequestMessage * request,
 #undef PEGASUS_RESPONSE_HANDLER_DERIVED_CONSTRUCT          CIMResponseMessage * response,
 #define PEGASUS_RESPONSE_HANDLER_DERIVED_CONSTRUCT(c,b)  
   
         PEGASUS_RESPONSE_HANDLER_DERIVED_INIT(EnableIndications, SimpleIndication);  
   
         EnableIndicationsResponseHandler  
         (CIMEnableIndicationsRequestMessage * request,  
          CIMEnableIndicationsResponseMessage * response,  
          CIMInstance & provider,          CIMInstance & provider,
          PEGASUS_INDICATION_CALLBACK indicationCallback)          PEGASUS_INDICATION_CALLBACK indicationCallback)
     : OperationResponseHandler(request, response),     : OperationResponseHandler(request, response),
                         _request_copy(*request),  
                         _response_copy(*response),  
                         _indicationCallback(indicationCallback)                         _indicationCallback(indicationCallback)
         {         {
                 _provider = provider;                 _provider = provider;
         }         }
  
         // this handler will not send async but sync  
         virtual Boolean isAsync() 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);
         }         }
  
         virtual void deliver(const OperationContext & context, const CIMIndication & cimIndication)         virtual void deliver(const OperationContext & context, const CIMIndication & cimIndication)
         {         {
           if(cimIndication.isUninitialized())
           {
               MessageLoaderParms message(
                   "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
                   "The object is not initialized.");
   
               throw CIMException(CIM_ERR_FAILED, message);
           }
   
                 // 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 863 
  
                 // 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 893 
                                                                                                                                                                                  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 462 
Line 921 
                 }                 }
         }         }
  
   protected:
       virtual String getClass(void) const
       {
           return(String("EnableIndicationsResponseHandler"));
       }
   
       virtual Boolean isAsync(void) const
       {
           return(false);
       }
   
 private: private:
         CIMEnableIndicationsRequestMessage _request_copy;  
         CIMEnableIndicationsResponseMessage _response_copy;  
         PEGASUS_INDICATION_CALLBACK _indicationCallback;         PEGASUS_INDICATION_CALLBACK _indicationCallback;
  
 }; };
  
 #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.22
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2