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

Diff for /pegasus/src/Pegasus/ProviderManager2/OperationResponseHandler.cpp between version 1.11.8.2 and 1.27

version 1.11.8.2, 2006/02/10 16:12:57 version 1.27, 2008/11/12 17:22:36
Line 29 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Chip Vincent (cvincent@us.ibm.com)  
 //  
 // Modified By:  
 //         Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase2  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "OperationResponseHandler.h" #include "OperationResponseHandler.h"
   #include "CIMOMHandleContext.h"
  
 #include <Pegasus/Common/Logger.h>  #include <Pegasus/Common/Tracer.h>
   #include <Pegasus/Common/SharedPtr.h>
 #include <Pegasus/ProviderManager2/ProviderManagerService.h>  #include <Pegasus/Provider/CIMOMHandle.h>
   #include <Pegasus/Config/ConfigManager.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   static void _initializeNormalizer(
       CIMOperationRequestMessage *request,
       Boolean includeQualifiers,
       Boolean includeClassOrigin,
       ObjectNormalizer &normalizer)
   {
       // Attempt to get the cached class definition, normalization is disabled
       // if it does not exist.
       if (request->operationContext.contains(
               CachedClassDefinitionContainer::NAME))
       {
           CIMClass cimClass;
           CachedClassDefinitionContainer container =
               request->operationContext.get(
                   CachedClassDefinitionContainer::NAME);
           cimClass = container.getClass();
           SharedPtr<NormalizerContext> tmpContext(new CIMOMHandleContext());
           ObjectNormalizer tmpNormalizer(
               cimClass,
               includeQualifiers,
               includeClassOrigin,
               request->nameSpace,
               tmpContext);
           normalizer = tmpNormalizer;
       }
   }
   
 // //
 // OperationResponseHandler // OperationResponseHandler
 // //
  
 OperationResponseHandler::OperationResponseHandler( OperationResponseHandler::OperationResponseHandler(
     CIMRequestMessage *request,     CIMRequestMessage *request,
     CIMResponseMessage *response)      CIMResponseMessage* response,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
     : _request(request),     : _request(request),
     _response(response),     _response(response),
       _responseChunkCallback(responseChunkCallback),
     _responseObjectTotal(0),     _responseObjectTotal(0),
     _responseMessageTotal(0),     _responseMessageTotal(0),
         _responseObjectThreshold(0)         _responseObjectThreshold(0)
Line 64 
Line 90 
  #define PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD  ~0  #define PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD  ~0
 #endif #endif
  
     if (!request || (request->requestIsOOP == true))      if (!request)
     {     {
         _responseObjectThreshold = ~0;         _responseObjectThreshold = ~0;
     }     }
Line 95 
Line 121 
         _response = 0;         _response = 0;
 } }
  
 CIMRequestMessage * OperationResponseHandler::getRequest(void) const  CIMRequestMessage* OperationResponseHandler::getRequest() const
 { {
     return(_request);      return _request;
 } }
  
 CIMResponseMessage * OperationResponseHandler::getResponse(void) const  CIMResponseMessage* OperationResponseHandler::getResponse() const
 { {
     return(_response);      return _response;
 } }
  
 void OperationResponseHandler::setStatus( void OperationResponseHandler::setStatus(
     const Uint32 code,     const Uint32 code,
     const String & message)     const String & message)
 { {
     _response->cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(code), message);      _response->cimException =
           PEGASUS_CIM_EXCEPTION(CIMStatusCode(code), message);
 } }
  
 void OperationResponseHandler::setStatus( void OperationResponseHandler::setStatus(
Line 124 
Line 151 
         message);         message);
 } }
  
 Boolean OperationResponseHandler::isAsync(void) const  void OperationResponseHandler::setCIMException(
       const CIMException& cimException)
   {
       // Assign the cimException argument to _response->cimException. Note that
       // there is no need to use the PEGASUS_CIM_EXCEPTION_LANG() macro to create
       // a TraceableCIMException since both _response->cimException and
       // cimException are of type CIMException and the TraceableCIMException
       // constructor has no side effects.
       _response->cimException = cimException;
   }
   
   Boolean OperationResponseHandler::isAsync() const
 { {
     return(true);      return _responseChunkCallback != 0;
 } }
  
 // This is only called from SimpleResponseHandler.deliver() but lives in this // This is only called from SimpleResponseHandler.deliver() but lives in this
Line 134 
Line 172 
 // to go through. Only operation classes have a response pointer // to go through. Only operation classes have a response pointer
 void OperationResponseHandler::send(Boolean isComplete) void OperationResponseHandler::send(Boolean isComplete)
 { {
         // some handlers do not send async because their callers cannot handle      // It is possible to instantiate this class directly (not a derived
         // partial responses. If this is the case, stop here.      // class, which would also inherit from SimpleResponseHandler).
       // The caller would do this only if the operation does not have any
         if (isAsync() == false)      // data to be returned.
         {  
                 // preserve tradional behavior      SimpleResponseHandler* simpleP =
                 if (isComplete == true)          dynamic_cast<SimpleResponseHandler*>(this);
       if (simpleP == 0)
         {         {
             transfer();          // if there is no data to be returned, then the message should NEVER be
         }          // incomplete (even on an error)
           PEGASUS_ASSERT(isComplete);
         return;         return;
         }         }
  
         SimpleResponseHandler *simpleP = dynamic_cast<SimpleResponseHandler*>(this);      // some handlers do not send async because their callers cannot handle
       // partial responses. If this is the case, stop here.
         // It is possible to instantiate this class directly (not derived)  
         // The caller would do this only if the operation does not have any data to  
         // be returned  
  
         if (! simpleP)      if (!isAsync())
         {         {
                 // if there is no data to be returned, then the message should NEVER be          // preserve traditional behavior
                 // incomplete (even on an error)          if (isComplete)
                 if (isComplete == false)          {
               if (_response != 0)
         {         {
             PEGASUS_ASSERT(false);                  _response->operationContext.set(
                       ContentLanguageListContainer(simpleP->getLanguages()));
               }
               transfer();
         }         }
  
         return;         return;
Line 190 
Line 230 
         _response->setComplete(isComplete);         _response->setComplete(isComplete);
         _responseObjectTotal += objectCount;         _responseObjectTotal += objectCount;
  
         // since we are reusing response for every chunk,keep track of original count      // since we are reusing response for every chunk, keep track of original
       // count
         _response->setIndex(_responseMessageTotal++);         _response->setIndex(_responseMessageTotal++);
  
         // set the originally allocated response to one more than the current.         // set the originally allocated response to one more than the current.
Line 209 
Line 250 
         simple.clear();         simple.clear();
     }     }
  
         String function = getClass() + "::" + "transfer";      PEG_TRACE((
         Logger::put(          TRC_PROVIDERMANAGER,
         Logger::STANDARD_LOG,          Tracer::LEVEL4,
         System::CIMSERVER,          "%s::transfer",
         Logger::TRACE,          (const char*) getClass().getCString()));
         function);  
  
         transfer();         transfer();
         simple.clear();         simple.clear();
  
         // l10n      _response->operationContext.set(
         _response->operationContext.set(ContentLanguageListContainer(simple.getLanguages()));          ContentLanguageListContainer(simple.getLanguages()));
  
         // call thru ProviderManager to get externally declared entry point         // call thru ProviderManager to get externally declared entry point
  
         if (isComplete == false)         if (isComplete == false)
         {         {
                 ProviderManagerService::handleCimResponse(*_request, *_response);          _responseChunkCallback(_request, _response);
         }         }
  
         // put caller's allocated response back in place. Note that _response         // put caller's allocated response back in place. Note that _response
Line 235 
Line 275 
         _response = response;         _response = response;
 } }
  
 void OperationResponseHandler::transfer(void)  void OperationResponseHandler::transfer()
 { {
 } }
  
 void OperationResponseHandler::validate(void)  void OperationResponseHandler::validate()
 { {
 } }
  
 String OperationResponseHandler::getClass(void) const  String OperationResponseHandler::getClass() const
 { {
     return(String("OperationResponseHandler"));      return String("OperationResponseHandler");
 } }
  
 Uint32 OperationResponseHandler::getResponseObjectTotal(void) const  Uint32 OperationResponseHandler::getResponseObjectTotal() const
 { {
     return(_responseObjectTotal);      return _responseObjectTotal;
 } }
  
 Uint32 OperationResponseHandler::getResponseMessageTotal(void) const  Uint32 OperationResponseHandler::getResponseMessageTotal() const
 { {
     return(_responseMessageTotal);      return _responseMessageTotal;
 } }
  
 Uint32 OperationResponseHandler::getResponseObjectThreshold(void) const  Uint32 OperationResponseHandler::getResponseObjectThreshold() const
 { {
     return(_responseObjectThreshold);      return _responseObjectThreshold;
 } }
  
 // //
Line 269 
Line 309 
  
 GetInstanceResponseHandler::GetInstanceResponseHandler( GetInstanceResponseHandler::GetInstanceResponseHandler(
     CIMGetInstanceRequestMessage * request,     CIMGetInstanceRequestMessage * request,
     CIMGetInstanceResponseMessage * response)      CIMGetInstanceResponseMessage* response,
     : OperationResponseHandler(request, response)      PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
 { {
     #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION      _initializeNormalizer(
     // Attempt to get the cached class definition used to validate results of this          request,
     // operation. If it does not exist, then this feature is disabled for this  
     // operation.  
     CIMClass cimClass;  
   
     NormalizerContext * context = 0;  
   
     try  
     {  
         CachedClassDefinitionContainer container =  
             request->operationContext.get(CachedClassDefinitionContainer::NAME);  
   
         cimClass = container.getClass();  
 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT  
         NormalizerContextContainer contextContainer =  
             request->operationContext.get(NormalizerContextContainer::NAME);  
         context = contextContainer.getContext();  
 #endif //PEGASUS_EMBEDDED_INSTANCE_SUPPORT  
     }  
     catch(Exception &)  
     {  
         // Do nothing. Container is missing, which implies normalization is disabled  
         // for this operation.  
     }  
   
     _normalizer =  
         ObjectNormalizer(  
             cimClass,  
             request->includeQualifiers,             request->includeQualifiers,
             request->includeClassOrigin,             request->includeClassOrigin,
             request->nameSpace,          _normalizer);
             context);  
     #endif  
 } }
  
 void GetInstanceResponseHandler::deliver(const CIMInstance & cimInstance) void GetInstanceResponseHandler::deliver(const CIMInstance & cimInstance)
Line 328 
Line 340 
         throw CIMException(CIM_ERR_FAILED, message);         throw CIMException(CIM_ERR_FAILED, message);
     }     }
  
       CIMInstance localInstance(cimInstance);
     #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION     #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
     // The normalizer expects an object path embedded in instances even     // The normalizer expects an object path embedded in instances even
     // though it is not required by this operation. Use the requested     // though it is not required by this operation. Use the requested
     // object path is missing from the instance.     // object path is missing from the instance.
     CIMInstance localInstance(cimInstance);  
   
     if(localInstance.getPath().getKeyBindings().size() == 0)     if(localInstance.getPath().getKeyBindings().size() == 0)
     {     {
         // ATTN: should clone before modification         // ATTN: should clone before modification
         localInstance.setPath(static_cast<CIMGetInstanceRequestMessage *>(getRequest())->instanceName);          localInstance.setPath(static_cast<CIMGetInstanceRequestMessage*>(
               getRequest())->instanceName);
     }     }
   
     SimpleInstanceResponseHandler::deliver(_normalizer.processInstance(localInstance));  
     #else  
     SimpleInstanceResponseHandler::deliver(cimInstance);  
     #endif     #endif
       SimpleInstanceResponseHandler::deliver(
           _normalizer.processInstance(localInstance));
 } }
  
 void GetInstanceResponseHandler::complete(void)  void GetInstanceResponseHandler::complete()
 { {
     if(SimpleInstanceResponseHandler::size() == 0)     if(SimpleInstanceResponseHandler::size() == 0)
     {     {
         MessageLoaderParms message(         MessageLoaderParms message(
             "Server.OperationResponseHandler.TOO_FEW_OBJECTS_DELIVERED",             "Server.OperationResponseHandler.TOO_FEW_OBJECTS_DELIVERED",
             "Too few objects delivered.");             "Too few objects delivered.");
           // Provider claims success, no instances returned. -V see Bug #4104
           setStatus(CIM_ERR_NOT_FOUND);
         throw CIMException(CIM_ERR_FAILED, message);         throw CIMException(CIM_ERR_FAILED, message);
     }     }
  
     SimpleInstanceResponseHandler::complete();     SimpleInstanceResponseHandler::complete();
 } }
  
 String GetInstanceResponseHandler::getClass(void) const  String GetInstanceResponseHandler::getClass() const
 { {
     return(String("GetInstanceResponseHandler"));      return String("GetInstanceResponseHandler");
 } }
  
 void GetInstanceResponseHandler::transfer(void)  void GetInstanceResponseHandler::transfer()
 { {
     if(size() > 0)     if(size() > 0)
     {     {
         CIMGetInstanceResponseMessage & msg =         CIMGetInstanceResponseMessage & msg =
             *static_cast<CIMGetInstanceResponseMessage *>(getResponse());             *static_cast<CIMGetInstanceResponseMessage *>(getResponse());
  
         msg.cimInstance = getObjects()[0];          msg.setCimInstance(getObjects()[0]);
     }     }
 } }
  
 void GetInstanceResponseHandler::validate(void)  void GetInstanceResponseHandler::validate()
 { {
     if(getResponseObjectTotal() == 0)     if(getResponseObjectTotal() == 0)
     {     {
Line 392 
Line 403 
  
 EnumerateInstancesResponseHandler::EnumerateInstancesResponseHandler( EnumerateInstancesResponseHandler::EnumerateInstancesResponseHandler(
     CIMEnumerateInstancesRequestMessage * request,     CIMEnumerateInstancesRequestMessage * request,
     CIMEnumerateInstancesResponseMessage * response)      CIMEnumerateInstancesResponseMessage* response,
     : OperationResponseHandler(request, response)      PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
 { {
     #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION      _initializeNormalizer(
     // Attempt to get the cached class definition used to validate results of this          request,
     // operation. If it does not exist, then this feature is disabled for this  
     // operation.  
     CIMClass cimClass;  
     NormalizerContext * context = 0;  
   
     try  
     {  
         CachedClassDefinitionContainer container =  
             request->operationContext.get(CachedClassDefinitionContainer::NAME);  
   
         cimClass = container.getClass();  
 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT  
         NormalizerContextContainer contextContainer =  
             request->operationContext.get(NormalizerContextContainer::NAME);  
         context = contextContainer.getContext();  
 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT  
     }  
     catch(Exception &)  
     {  
         // Do nothing. Container is missing, which implies normalization is disabled  
         // for this operation.  
     }  
   
     _normalizer =  
         ObjectNormalizer(  
             cimClass,  
             request->includeQualifiers,             request->includeQualifiers,
             request->includeClassOrigin,             request->includeClassOrigin,
             request->nameSpace,          _normalizer);
             context);  
     #endif  
 } }
  
 void EnumerateInstancesResponseHandler::deliver(const CIMInstance & cimInstance) void EnumerateInstancesResponseHandler::deliver(const CIMInstance & cimInstance)
Line 441 
Line 425 
         throw CIMException(CIM_ERR_FAILED, message);         throw CIMException(CIM_ERR_FAILED, message);
     }     }
  
     #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION      SimpleInstanceResponseHandler::deliver(
     SimpleInstanceResponseHandler::deliver(_normalizer.processInstance(cimInstance));          _normalizer.processInstance(cimInstance));
     #else  
     SimpleInstanceResponseHandler::deliver(cimInstance);  
     #endif  
 } }
  
 String EnumerateInstancesResponseHandler::getClass(void) const  String EnumerateInstancesResponseHandler::getClass() const
 { {
     return(String("EnumerateInstancesResponseHandler"));      return String("EnumerateInstancesResponseHandler");
 } }
  
 void EnumerateInstancesResponseHandler::transfer(void)  void EnumerateInstancesResponseHandler::transfer()
 { {
     CIMEnumerateInstancesResponseMessage & msg =     CIMEnumerateInstancesResponseMessage & msg =
         *static_cast<CIMEnumerateInstancesResponseMessage *>(getResponse());         *static_cast<CIMEnumerateInstancesResponseMessage *>(getResponse());
  
     msg.cimNamedInstances = getObjects();      msg.setNamedInstances(getObjects());
 } }
  
 // //
Line 467 
Line 448 
  
 EnumerateInstanceNamesResponseHandler::EnumerateInstanceNamesResponseHandler( EnumerateInstanceNamesResponseHandler::EnumerateInstanceNamesResponseHandler(
     CIMEnumerateInstanceNamesRequestMessage * request,     CIMEnumerateInstanceNamesRequestMessage * request,
     CIMEnumerateInstanceNamesResponseMessage * response)      CIMEnumerateInstanceNamesResponseMessage* response,
     : OperationResponseHandler(request, response)      PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
 {      : OperationResponseHandler(request, response, responseChunkCallback)
     #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION  
     // Attempt to get the cached class definition used to validate results of this  
     // operation. If it does not exist, then this feature is disabled for this  
     // operation.  
     CIMClass cimClass;  
     NormalizerContext * context = 0;  
   
     try  
     {     {
         CachedClassDefinitionContainer container =      _initializeNormalizer(
             request->operationContext.get(CachedClassDefinitionContainer::NAME);          request,
   
         cimClass = container.getClass();  
 #ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT  
         NormalizerContextContainer contextContainer =  
             request->operationContext.get(NormalizerContextContainer::NAME);  
         context = contextContainer.getContext();  
 #endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT  
     }  
     catch(Exception &)  
     {  
         // Do nothing. Container is missing, which implies normalization is disabled  
         // for this operation.  
     }  
   
     _normalizer =  
         ObjectNormalizer(  
             cimClass,  
             false,             false,
             false,             false,
             request->nameSpace,          _normalizer);
             context);  
     #endif  
 } }
  
 void EnumerateInstanceNamesResponseHandler::deliver(const CIMObjectPath & cimObjectPath)  void EnumerateInstanceNamesResponseHandler::deliver(
       const CIMObjectPath& cimObjectPath)
 { {
     if(cimObjectPath.getClassName().isNull())     if(cimObjectPath.getClassName().isNull())
     {     {
Line 516 
Line 471 
         throw CIMException(CIM_ERR_FAILED, message);         throw CIMException(CIM_ERR_FAILED, message);
     }     }
  
     #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION      SimpleObjectPathResponseHandler::deliver(
     SimpleObjectPathResponseHandler::deliver(_normalizer.processInstanceObjectPath(cimObjectPath));          _normalizer.processInstanceObjectPath(cimObjectPath));
     #else  
     SimpleObjectPathResponseHandler::deliver(cimObjectPath);  
     #endif  
 } }
  
 String EnumerateInstanceNamesResponseHandler::getClass(void) const  String EnumerateInstanceNamesResponseHandler::getClass() const
 { {
     return(String("EnumerateInstanceNamesResponseHandler"));      return String("EnumerateInstanceNamesResponseHandler");
 } }
  
 void EnumerateInstanceNamesResponseHandler::transfer(void)  void EnumerateInstanceNamesResponseHandler::transfer()
 { {
     CIMEnumerateInstanceNamesResponseMessage & msg =     CIMEnumerateInstanceNamesResponseMessage & msg =
         *static_cast<CIMEnumerateInstanceNamesResponseMessage *>(getResponse());         *static_cast<CIMEnumerateInstanceNamesResponseMessage *>(getResponse());
Line 542 
Line 494 
  
 CreateInstanceResponseHandler::CreateInstanceResponseHandler( CreateInstanceResponseHandler::CreateInstanceResponseHandler(
     CIMCreateInstanceRequestMessage * request,     CIMCreateInstanceRequestMessage * request,
     CIMCreateInstanceResponseMessage * response)      CIMCreateInstanceResponseMessage* response,
     : OperationResponseHandler(request, response)      PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
 { {
 } }
  
Line 570 
Line 523 
     SimpleObjectPathResponseHandler::deliver(cimObjectPath);     SimpleObjectPathResponseHandler::deliver(cimObjectPath);
 } }
  
 void CreateInstanceResponseHandler::complete(void)  void CreateInstanceResponseHandler::complete()
 { {
     if(SimpleObjectPathResponseHandler::size() == 0)     if(SimpleObjectPathResponseHandler::size() == 0)
     {     {
Line 584 
Line 537 
     SimpleObjectPathResponseHandler::complete();     SimpleObjectPathResponseHandler::complete();
 } }
  
 String CreateInstanceResponseHandler::getClass(void) const  String CreateInstanceResponseHandler::getClass() const
 { {
     return(String("CreateInstanceResponseHandler"));      return String("CreateInstanceResponseHandler");
 } }
  
 #if 0 #if 0
 // ATTN: is it an error to not return instance name? // ATTN: is it an error to not return instance name?
 void CreateInstanceResponseHandler::validate(void)  void CreateInstanceResponseHandler::validate()
 { {
     if(getResponseObjectTotal() == 0)     if(getResponseObjectTotal() == 0)
     {     {
Line 600 
Line 553 
 } }
 #endif #endif
  
 void CreateInstanceResponseHandler::transfer(void)  void CreateInstanceResponseHandler::transfer()
 { {
     if(size() > 0)     if(size() > 0)
     {     {
Line 617 
Line 570 
  
 ModifyInstanceResponseHandler::ModifyInstanceResponseHandler( ModifyInstanceResponseHandler::ModifyInstanceResponseHandler(
     CIMModifyInstanceRequestMessage * request,     CIMModifyInstanceRequestMessage * request,
     CIMModifyInstanceResponseMessage * response)      CIMModifyInstanceResponseMessage* response,
     : OperationResponseHandler(request, response)      PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
 { {
 } }
  
 String ModifyInstanceResponseHandler::getClass(void) const  String ModifyInstanceResponseHandler::getClass() const
 { {
     return(String("ModifyInstanceResponseHandler"));      return String("ModifyInstanceResponseHandler");
 } }
  
 // //
Line 633 
Line 587 
  
 DeleteInstanceResponseHandler::DeleteInstanceResponseHandler( DeleteInstanceResponseHandler::DeleteInstanceResponseHandler(
     CIMDeleteInstanceRequestMessage * request,     CIMDeleteInstanceRequestMessage * request,
     CIMDeleteInstanceResponseMessage * response)      CIMDeleteInstanceResponseMessage* response,
     : OperationResponseHandler(request, response)      PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
 { {
 } }
  
 String DeleteInstanceResponseHandler::getClass(void) const  String DeleteInstanceResponseHandler::getClass() const
 { {
     return(String("DeleteInstanceResponseHandler"));      return String("DeleteInstanceResponseHandler");
 } }
  
 // //
Line 649 
Line 604 
  
 GetPropertyResponseHandler::GetPropertyResponseHandler( GetPropertyResponseHandler::GetPropertyResponseHandler(
     CIMGetPropertyRequestMessage * request,     CIMGetPropertyRequestMessage * request,
     CIMGetPropertyResponseMessage * response)      CIMGetPropertyResponseMessage* response,
     : OperationResponseHandler(request, response)      PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
 { {
 } }
  
Line 668 
Line 624 
     SimpleValueResponseHandler::deliver(cimValue);     SimpleValueResponseHandler::deliver(cimValue);
 } }
  
 String GetPropertyResponseHandler::getClass(void) const  String GetPropertyResponseHandler::getClass() const
 { {
     return(String("GetPropertyResponseHandler"));      return String("GetPropertyResponseHandler");
 } }
  
 void GetPropertyResponseHandler::transfer(void)  void GetPropertyResponseHandler::transfer()
 { {
     if(size() > 0)     if(size() > 0)
     {     {
Line 684 
Line 640 
     }     }
 } }
  
 void GetPropertyResponseHandler::validate(void)  void GetPropertyResponseHandler::validate()
 { {
     // error? provider claims success,     // error? provider claims success,
     // but did not deliver an instance.     // but did not deliver an instance.
Line 700 
Line 656 
  
 SetPropertyResponseHandler::SetPropertyResponseHandler( SetPropertyResponseHandler::SetPropertyResponseHandler(
     CIMSetPropertyRequestMessage * request,     CIMSetPropertyRequestMessage * request,
     CIMSetPropertyResponseMessage * response)      CIMSetPropertyResponseMessage* response,
     : OperationResponseHandler(request, response)      PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
 { {
 } }
  
 String SetPropertyResponseHandler::getClass(void) const  String SetPropertyResponseHandler::getClass() const
 { {
     return(String("SetPropertyResponseHandler"));      return String("SetPropertyResponseHandler");
 } }
  
 // //
Line 716 
Line 673 
  
 ExecQueryResponseHandler::ExecQueryResponseHandler( ExecQueryResponseHandler::ExecQueryResponseHandler(
     CIMExecQueryRequestMessage * request,     CIMExecQueryRequestMessage * request,
     CIMExecQueryResponseMessage * response)      CIMExecQueryResponseMessage* response,
     : OperationResponseHandler(request, response)      PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
 { {
 } }
  
Line 735 
Line 693 
     SimpleInstance2ObjectResponseHandler::deliver(cimInstance);     SimpleInstance2ObjectResponseHandler::deliver(cimInstance);
 } }
  
 String ExecQueryResponseHandler::getClass(void) const  String ExecQueryResponseHandler::getClass() const
 { {
     return(String("ExecQueryResponseHandler"));      return String("ExecQueryResponseHandler");
 } }
  
 void ExecQueryResponseHandler::transfer(void)  void ExecQueryResponseHandler::transfer()
 { {
     CIMExecQueryResponseMessage & msg =     CIMExecQueryResponseMessage & msg =
         *static_cast<CIMExecQueryResponseMessage *>(getResponse());         *static_cast<CIMExecQueryResponseMessage *>(getResponse());
Line 748 
Line 706 
     msg.cimObjects = getObjects();     msg.cimObjects = getObjects();
 } }
  
 Boolean ExecQueryResponseHandler::isAsync(void) const  Boolean ExecQueryResponseHandler::isAsync() const
 { {
     return(false);      return false;
 } }
  
 // //
Line 759 
Line 717 
  
 AssociatorsResponseHandler::AssociatorsResponseHandler( AssociatorsResponseHandler::AssociatorsResponseHandler(
     CIMAssociatorsRequestMessage * request,     CIMAssociatorsRequestMessage * request,
     CIMAssociatorsResponseMessage * response)      CIMAssociatorsResponseMessage* response,
     : OperationResponseHandler(request, response)      PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
 { {
 } }
  
Line 778 
Line 737 
     SimpleObjectResponseHandler::deliver(cimObject);     SimpleObjectResponseHandler::deliver(cimObject);
 } }
  
 String AssociatorsResponseHandler::getClass(void) const  String AssociatorsResponseHandler::getClass() const
 { {
     return(String("AssociatorsResponseHandler"));      return String("AssociatorsResponseHandler");
 } }
  
 void AssociatorsResponseHandler::transfer(void)  void AssociatorsResponseHandler::transfer()
 { {
     CIMAssociatorsResponseMessage & msg =     CIMAssociatorsResponseMessage & msg =
         *static_cast<CIMAssociatorsResponseMessage *>(getResponse());         *static_cast<CIMAssociatorsResponseMessage *>(getResponse());
Line 797 
Line 756 
  
 AssociatorNamesResponseHandler::AssociatorNamesResponseHandler( AssociatorNamesResponseHandler::AssociatorNamesResponseHandler(
     CIMAssociatorNamesRequestMessage * request,     CIMAssociatorNamesRequestMessage * request,
     CIMAssociatorNamesResponseMessage * response)      CIMAssociatorNamesResponseMessage* response,
     : OperationResponseHandler(request, response)      PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
 { {
 } }
  
Line 816 
Line 776 
     SimpleObjectPathResponseHandler::deliver(cimObjectPath);     SimpleObjectPathResponseHandler::deliver(cimObjectPath);
 } }
  
 String AssociatorNamesResponseHandler::getClass(void) const  String AssociatorNamesResponseHandler::getClass() const
 { {
     return(String("AssociatorNamesResponseHandler"));      return String("AssociatorNamesResponseHandler");
 } }
  
 void AssociatorNamesResponseHandler::transfer(void)  void AssociatorNamesResponseHandler::transfer()
 { {
     CIMAssociatorNamesResponseMessage & msg =     CIMAssociatorNamesResponseMessage & msg =
         *static_cast<CIMAssociatorNamesResponseMessage *>(getResponse());         *static_cast<CIMAssociatorNamesResponseMessage *>(getResponse());
Line 835 
Line 795 
  
 ReferencesResponseHandler::ReferencesResponseHandler( ReferencesResponseHandler::ReferencesResponseHandler(
     CIMReferencesRequestMessage * request,     CIMReferencesRequestMessage * request,
     CIMReferencesResponseMessage * response)      CIMReferencesResponseMessage* response,
     : OperationResponseHandler(request, response)      PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
 { {
 } }
  
Line 854 
Line 815 
     SimpleObjectResponseHandler::deliver(cimObject);     SimpleObjectResponseHandler::deliver(cimObject);
 } }
  
 String ReferencesResponseHandler::getClass(void) const  String ReferencesResponseHandler::getClass() const
 { {
     return(String("ReferencesResponseHandler"));      return String("ReferencesResponseHandler");
 } }
  
 void ReferencesResponseHandler::transfer(void)  void ReferencesResponseHandler::transfer()
 { {
     CIMReferencesResponseMessage & msg =     CIMReferencesResponseMessage & msg =
         *static_cast<CIMReferencesResponseMessage *>(getResponse());         *static_cast<CIMReferencesResponseMessage *>(getResponse());
Line 873 
Line 834 
  
 ReferenceNamesResponseHandler::ReferenceNamesResponseHandler( ReferenceNamesResponseHandler::ReferenceNamesResponseHandler(
     CIMReferenceNamesRequestMessage * request,     CIMReferenceNamesRequestMessage * request,
     CIMReferenceNamesResponseMessage * response)      CIMReferenceNamesResponseMessage* response,
     : OperationResponseHandler(request, response)      PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
 { {
 } }
  
Line 892 
Line 854 
     SimpleObjectPathResponseHandler::deliver(cimObjectPath);     SimpleObjectPathResponseHandler::deliver(cimObjectPath);
 } }
  
 String ReferenceNamesResponseHandler::getClass(void) const  String ReferenceNamesResponseHandler::getClass() const
 { {
     return(String("ReferenceNamesResponseHandler"));      return String("ReferenceNamesResponseHandler");
 } }
  
 void ReferenceNamesResponseHandler::transfer(void)  void ReferenceNamesResponseHandler::transfer()
 { {
     CIMReferenceNamesResponseMessage & msg =     CIMReferenceNamesResponseMessage & msg =
         *static_cast<CIMReferenceNamesResponseMessage *>(getResponse());         *static_cast<CIMReferenceNamesResponseMessage *>(getResponse());
Line 911 
Line 873 
  
 InvokeMethodResponseHandler::InvokeMethodResponseHandler( InvokeMethodResponseHandler::InvokeMethodResponseHandler(
     CIMInvokeMethodRequestMessage * request,     CIMInvokeMethodRequestMessage * request,
     CIMInvokeMethodResponseMessage * response)      CIMInvokeMethodResponseMessage* response,
     : OperationResponseHandler(request, response)      PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
 { {
 } }
  
 void InvokeMethodResponseHandler::deliverParamValue(const CIMParamValue & cimParamValue)  void InvokeMethodResponseHandler::deliverParamValue(
       const CIMParamValue& cimParamValue)
 { {
     if(cimParamValue.isUninitialized())     if(cimParamValue.isUninitialized())
     {     {
Line 944 
Line 908 
     SimpleMethodResultResponseHandler::deliver(cimValue);     SimpleMethodResultResponseHandler::deliver(cimValue);
 } }
  
 String InvokeMethodResponseHandler::getClass(void) const  String InvokeMethodResponseHandler::getClass() const
 { {
     return(String("InvokeMethodResponseHandler"));      return String("InvokeMethodResponseHandler");
 } }
  
 void InvokeMethodResponseHandler::transfer(void)  void InvokeMethodResponseHandler::transfer()
 { {
     CIMInvokeMethodResponseMessage & msg =     CIMInvokeMethodResponseMessage & msg =
         *static_cast<CIMInvokeMethodResponseMessage *>(getResponse());         *static_cast<CIMInvokeMethodResponseMessage *>(getResponse());
Line 966 
Line 930 
 // EnableIndicationsResponseHandler // EnableIndicationsResponseHandler
 // //
  
 typedef void (*PEGASUS_INDICATION_CALLBACK)(CIMProcessIndicationRequestMessage*);  
   
 EnableIndicationsResponseHandler::EnableIndicationsResponseHandler( EnableIndicationsResponseHandler::EnableIndicationsResponseHandler(
     CIMRequestMessage * request,     CIMRequestMessage * request,
     CIMResponseMessage * response,     CIMResponseMessage * response,
     CIMInstance & provider,      const CIMInstance& provider,
     PEGASUS_INDICATION_CALLBACK indicationCallback)      PEGASUS_INDICATION_CALLBACK_T indicationCallback,
     : OperationResponseHandler(request, response),      PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback),
     _indicationCallback(indicationCallback)     _indicationCallback(indicationCallback)
 { {
     _provider = provider;     _provider = provider;
 } }
  
 void EnableIndicationsResponseHandler::deliver(const CIMIndication & cimIndication)  void EnableIndicationsResponseHandler::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);
 } }
  
 void EnableIndicationsResponseHandler::deliver(const OperationContext & context, const CIMIndication & cimIndication)  void EnableIndicationsResponseHandler::deliver(
       const OperationContext& context,
       const CIMIndication& cimIndication)
 { {
     if(cimIndication.isUninitialized())     if(cimIndication.isUninitialized())
     {     {
Line 1007 
Line 974 
     //  Get list of subscription instance names from context     //  Get list of subscription instance names from context
     Array<CIMObjectPath> subscriptionInstanceNames;     Array<CIMObjectPath> subscriptionInstanceNames;
  
     try      if (context.contains(SubscriptionInstanceNamesContainer::NAME))
     {     {
         SubscriptionInstanceNamesContainer container =         SubscriptionInstanceNamesContainer container =
             context.get(SubscriptionInstanceNamesContainer::NAME);             context.get(SubscriptionInstanceNamesContainer::NAME);
  
         subscriptionInstanceNames = container.getInstanceNames();         subscriptionInstanceNames = container.getInstanceNames();
     }     }
     catch(Exception &)      else
     {     {
         subscriptionInstanceNames.clear();         subscriptionInstanceNames.clear();
     }     }
  
     // l10n  
     ContentLanguageList contentLangs;     ContentLanguageList contentLangs;
  
     try      if (context.contains(ContentLanguageListContainer::NAME))
     {     {
         // 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.
Line 1031 
Line 997 
  
         contentLangs = langContainer.getLanguages();         contentLangs = langContainer.getLanguages();
     }     }
     catch(Exception &)      else
     {     {
         // The provider did not explicitly set a Content-Language for         // The provider did not explicitly set a Content-Language for
         // the indication.  Fall back to the lang set in this object.         // the indication.  Fall back to the lang set in this object.
         contentLangs = getLanguages();         contentLangs = getLanguages();
     }     }
     // l10n -end  
  
     // create message     // create message
     // l10n  
     CIMProcessIndicationRequestMessage * request =     CIMProcessIndicationRequestMessage * request =
         new CIMProcessIndicationRequestMessage(         new CIMProcessIndicationRequestMessage(
         XmlWriter::getNextMessageId(),         XmlWriter::getNextMessageId(),
Line 1052 
Line 1016 
  
     request->operationContext = context;     request->operationContext = context;
  
     try      if (request->operationContext.contains(ContentLanguageListContainer::NAME))
     {     {
         request->operationContext.set(ContentLanguageListContainer(contentLangs));          request->operationContext.set(
               ContentLanguageListContainer(contentLangs));
     }     }
     catch(Exception &)      else
     {     {
         request->operationContext.insert(ContentLanguageListContainer(contentLangs));          request->operationContext.insert(
               ContentLanguageListContainer(contentLangs));
     }     }
  
     _indicationCallback(request);     _indicationCallback(request);
 } }
  
 void EnableIndicationsResponseHandler::deliver(const Array<CIMIndication> & cimIndications)  void EnableIndicationsResponseHandler::deliver(
       const Array<CIMIndication>& cimIndications)
 { {
     OperationContext context;     OperationContext context;
  
     deliver(context, cimIndications);     deliver(context, cimIndications);
 } }
  
 void EnableIndicationsResponseHandler::deliver(const OperationContext & context, const Array<CIMIndication> & cimIndications)  void EnableIndicationsResponseHandler::deliver(
       const OperationContext& context,
       const Array<CIMIndication>& cimIndications)
 { {
     for(Uint32 i = 0, n = cimIndications.size(); i < n; i++)     for(Uint32 i = 0, n = cimIndications.size(); i < n; i++)
     {     {
Line 1079 
Line 1048 
     }     }
 } }
  
 String EnableIndicationsResponseHandler::getClass(void) const  String EnableIndicationsResponseHandler::getClass() const
 { {
     return(String("EnableIndicationsResponseHandler"));      return String("EnableIndicationsResponseHandler");
 } }
  
 Boolean EnableIndicationsResponseHandler::isAsync(void) const  Boolean EnableIndicationsResponseHandler::isAsync() const
 { {
     return(false);      return false;
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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