(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.3 and 1.18

version 1.3, 2004/10/25 18:26:00 version 1.18, 2006/08/30 19:39:52
Line 1 
Line 1 
 //%2004////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
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.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 25 
Line 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 "ProviderManagerService.h"  #include "CIMOMHandleContext.h"
   
   #include <Pegasus/Common/Logger.h>
   #include <Pegasus/Common/AutoPtr.h>
   #include <Pegasus/Provider/CIMOMHandle.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 OperationResponseHandler::OperationResponseHandler  //
 (CIMRequestMessage *request,  // OperationResponseHandler
  CIMResponseMessage *response) :  //
         _request(request), _response(response)  
 {  
  
   OperationResponseHandler::OperationResponseHandler(
       CIMRequestMessage *request,
       CIMResponseMessage *response,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : _request(request),
       _response(response),
       _responseChunkCallback(responseChunkCallback),
       _responseObjectTotal(0),
       _responseMessageTotal(0),
       _responseObjectThreshold(0)
   {
 #ifndef PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD #ifndef PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD
 #define PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD 100 #define PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD 100
 #elif PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD  == 0 #elif PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD  == 0
Line 49 
Line 62 
 #define PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD  ~0 #define PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD  ~0
 #endif #endif
  
         _responseObjectTotal = 0;      if (!request)
         _responseMessageTotal = 0;      {
           _responseObjectThreshold = ~0;
       }
           else
       {
         _responseObjectThreshold = PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD;         _responseObjectThreshold = PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD;
  
 #ifdef PEGASUS_DEBUG #ifdef PEGASUS_DEBUG
         static const char *responseObjectThreshold =         static const char *responseObjectThreshold =
                 getenv("PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD");                 getenv("PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD");
   
         if (responseObjectThreshold)         if (responseObjectThreshold)
         {         {
                 Uint32 i = (Uint32) atoi(responseObjectThreshold);                 Uint32 i = (Uint32) atoi(responseObjectThreshold);
   
                 if (i > 0)                 if (i > 0)
               {
                         _responseObjectThreshold = i;                         _responseObjectThreshold = i;
         }         }
               }
 #endif #endif
 } }
   }
  
 OperationResponseHandler::~OperationResponseHandler() OperationResponseHandler::~OperationResponseHandler()
 { {
Line 71 
Line 93 
         _response = 0;         _response = 0;
 } }
  
   CIMRequestMessage * OperationResponseHandler::getRequest(void) const
   {
       return(_request);
   }
   
   CIMResponseMessage * OperationResponseHandler::getResponse(void) const
   {
       return(_response);
   }
   
   void OperationResponseHandler::setStatus(
       const Uint32 code,
       const String & message)
   {
       _response->cimException = PEGASUS_CIM_EXCEPTION(CIMStatusCode(code), message);
   }
   
   void OperationResponseHandler::setStatus(
       const Uint32 code,
       const ContentLanguageList & langs,
       const String & message)
   {
       _response->cimException =
           PEGASUS_CIM_EXCEPTION_LANG(
           langs,
           CIMStatusCode(code),
           message);
   }
   
   Boolean OperationResponseHandler::isAsync(void) const
   {
       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
 // class because all asyncronous response must have a "response" pointer // class because all asyncronous response must have a "response" pointer
 // 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)
 { {
       // It is possible to instantiate this class directly (not a derived
       // class, which would also inherit from SimpleResponseHandler).
       // The caller would do this only if the operation does not have any
       // data to be returned.
   
       SimpleResponseHandler* simpleP =
           dynamic_cast<SimpleResponseHandler*>(this);
       if (simpleP == 0)
       {
           // if there is no data to be returned, then the message should NEVER be
           // incomplete (even on an error)
           PEGASUS_ASSERT(isComplete);
           return;
       }
   
         // some handlers do not send async because their callers cannot handle         // some handlers do not send async because their callers cannot handle
         // partial responses. If this is the case, stop here.         // partial responses. If this is the case, stop here.
  
         if (isAsync() == false)      if (!isAsync())
         {         {
                 // preserve tradional behavior          // preserve traditional behavior
                 if (isComplete == true)          if (isComplete)
           {
               if (_response->operationContext.contains(
                       ContentLanguageListContainer::NAME))
               {
                   _response->operationContext.set(
                       ContentLanguageListContainer(simpleP->getLanguages()));
               }
                         transfer();                         transfer();
                 return;  
         }         }
  
         SimpleResponseHandler *simpleP = dynamic_cast<SimpleResponseHandler*>(this);  
   
         // 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 there is no data to be returned, then the message should NEVER be  
                 // incomplete (even on an error)  
                 if (isComplete == false)  
                         PEGASUS_ASSERT(false);  
                 return;                 return;
         }         }
  
Line 108 
Line 172 
         Uint32 objectCount = simple.size();         Uint32 objectCount = simple.size();
  
         // have not reached threshold yet         // have not reached threshold yet
         if (isComplete == false && objectCount < _responseObjectThreshold)          if ((isComplete == false) && (objectCount < _responseObjectThreshold))
       {
                 return;                 return;
       }
  
         CIMResponseMessage *response = _response;         CIMResponseMessage *response = _response;
  
Line 118 
Line 184 
         // utilized for async responses underneath         // utilized for async responses underneath
  
         if (isComplete == false)         if (isComplete == false)
       {
                 _response = _request->buildResponse();                 _response = _request->buildResponse();
       }
  
         _response->setComplete(isComplete);         _response->setComplete(isComplete);
         _responseObjectTotal += objectCount;         _responseObjectTotal += objectCount;
Line 131 
Line 199 
         // allows the last response to be set as it may not re-enter this code.         // allows the last response to be set as it may not re-enter this code.
  
         if (isComplete == false)         if (isComplete == false)
       {
                 response->setIndex(_responseMessageTotal);                 response->setIndex(_responseMessageTotal);
       }
  
         validate();         validate();
  
         if (_response->cimException.getCode() != CIM_ERR_SUCCESS)         if (_response->cimException.getCode() != CIM_ERR_SUCCESS)
       {
                 simple.clear();                 simple.clear();
       }
  
         String function = getClass() + "::" + "transfer";         String function = getClass() + "::" + "transfer";
         Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,          Logger::put(
           Logger::STANDARD_LOG,
           System::CIMSERVER,
           Logger::TRACE,
                                                         function);                                                         function);
  
         transfer();         transfer();
         simple.clear();         simple.clear();
  
         // l10n         // l10n
         _response->operationContext.          _response->operationContext.set(ContentLanguageListContainer(simple.getLanguages()));
                 set(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 162 
Line 236 
         _response = response;         _response = response;
 } }
  
   void OperationResponseHandler::transfer(void)
   {
   }
   
   void OperationResponseHandler::validate(void)
   {
   }
   
   String OperationResponseHandler::getClass(void) const
   {
       return(String("OperationResponseHandler"));
   }
   
   Uint32 OperationResponseHandler::getResponseObjectTotal(void) const
   {
       return(_responseObjectTotal);
   }
   
   Uint32 OperationResponseHandler::getResponseMessageTotal(void) const
   {
       return(_responseMessageTotal);
   }
   
   Uint32 OperationResponseHandler::getResponseObjectThreshold(void) const
   {
       return(_responseObjectThreshold);
   }
   
   //
   // GetInstanceResponseHandler
   //
   
   GetInstanceResponseHandler::GetInstanceResponseHandler(
       CIMGetInstanceRequestMessage* request,
       CIMGetInstanceResponseMessage* 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;
   
       if(request->operationContext.contains(CachedClassDefinitionContainer::NAME))
       {
           CachedClassDefinitionContainer container =
               request->operationContext.get(
                   CachedClassDefinitionContainer::NAME);
   
           cimClass = container.getClass();
       }
   
       AutoPtr<NormalizerContext> tmpContext(new CIMOMHandleContext());
       ObjectNormalizer tmpNormalizer(
           cimClass,
           request->includeQualifiers,
           request->includeClassOrigin,
           request->nameSpace,
           tmpContext);
       _normalizer = tmpNormalizer;
       #endif
   }
   
   void GetInstanceResponseHandler::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);
       }
   
       if(SimpleInstanceResponseHandler::size() != 0)
       {
           MessageLoaderParms message(
               "Server.OperationResponseHandler.TOO_MANY_OBJECTS_DELIVERED",
               "Too many objects delivered.");
   
           throw CIMException(CIM_ERR_FAILED, message);
       }
   
       #ifdef PEGASUS_ENABLE_OBJECT_NORMALIZATION
       // The normalizer expects an object path embedded in instances even
       // though it is not required by this operation. Use the requested
       // object path is missing from the instance.
       CIMInstance localInstance(cimInstance);
   
       if(localInstance.getPath().getKeyBindings().size() == 0)
       {
           // ATTN: should clone before modification
           localInstance.setPath(static_cast<CIMGetInstanceRequestMessage *>(getRequest())->instanceName);
       }
   
       SimpleInstanceResponseHandler::deliver(_normalizer.processInstance(localInstance));
       #else
       SimpleInstanceResponseHandler::deliver(cimInstance);
       #endif
   }
   
   void GetInstanceResponseHandler::complete(void)
   {
       if(SimpleInstanceResponseHandler::size() == 0)
       {
           MessageLoaderParms message(
               "Server.OperationResponseHandler.TOO_FEW_OBJECTS_DELIVERED",
               "Too few objects delivered.");
   
           throw CIMException(CIM_ERR_FAILED, message);
       }
   
       SimpleInstanceResponseHandler::complete();
   }
   
   String GetInstanceResponseHandler::getClass(void) const
   {
       return(String("GetInstanceResponseHandler"));
   }
   
   void GetInstanceResponseHandler::transfer(void)
   {
       if(size() > 0)
       {
           CIMGetInstanceResponseMessage & msg =
               *static_cast<CIMGetInstanceResponseMessage *>(getResponse());
   
           msg.cimInstance = getObjects()[0];
       }
   }
   
   void GetInstanceResponseHandler::validate(void)
   {
       if(getResponseObjectTotal() == 0)
       {
           // error? provider claims success,
           // but did not deliver an instance.
           setStatus(CIM_ERR_NOT_FOUND);
       }
   }
   
   //
   // EnumerateInstancesResponseHandler
   //
   
   EnumerateInstancesResponseHandler::EnumerateInstancesResponseHandler(
       CIMEnumerateInstancesRequestMessage* request,
       CIMEnumerateInstancesResponseMessage* 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;
   
       if(request->operationContext.contains(CachedClassDefinitionContainer::NAME))
       {
           CachedClassDefinitionContainer container =
               request->operationContext.get(
                   CachedClassDefinitionContainer::NAME);
           cimClass = container.getClass();
       }
   
       AutoPtr<NormalizerContext> tmpContext(new CIMOMHandleContext());
       ObjectNormalizer tmpNormalizer(
           cimClass,
           request->includeQualifiers,
           request->includeClassOrigin,
           request->nameSpace,
           tmpContext);
       _normalizer = tmpNormalizer;
   #endif
   }
   
   void EnumerateInstancesResponseHandler::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
   }
   
   String EnumerateInstancesResponseHandler::getClass(void) const
   {
       return(String("EnumerateInstancesResponseHandler"));
   }
   
   void EnumerateInstancesResponseHandler::transfer(void)
   {
       CIMEnumerateInstancesResponseMessage & msg =
           *static_cast<CIMEnumerateInstancesResponseMessage *>(getResponse());
   
       msg.cimNamedInstances = getObjects();
   }
   
   //
   // EnumerateInstanceNamesResponseHandler
   //
   
   EnumerateInstanceNamesResponseHandler::EnumerateInstanceNamesResponseHandler(
       CIMEnumerateInstanceNamesRequestMessage* request,
       CIMEnumerateInstanceNamesResponseMessage* 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;
   
       if(request->operationContext.contains(CachedClassDefinitionContainer::NAME))
       {
           CachedClassDefinitionContainer container =
               request->operationContext.get(
                   CachedClassDefinitionContainer::NAME);
   
           cimClass = container.getClass();
       }
   
       AutoPtr<NormalizerContext> tmpContext(new CIMOMHandleContext());
       ObjectNormalizer tmpNormalizer(
           cimClass,
           false,
           false,
           request->nameSpace,
           tmpContext);
       _normalizer = tmpNormalizer;
   #endif
   }
   
   void EnumerateInstanceNamesResponseHandler::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
   }
   
   String EnumerateInstanceNamesResponseHandler::getClass(void) const
   {
       return(String("EnumerateInstanceNamesResponseHandler"));
   }
   
   void EnumerateInstanceNamesResponseHandler::transfer(void)
   {
       CIMEnumerateInstanceNamesResponseMessage & msg =
           *static_cast<CIMEnumerateInstanceNamesResponseMessage *>(getResponse());
   
       msg.instanceNames = getObjects();
   }
   
   //
   // CreateInstanceResponseHandler
   //
   
   CreateInstanceResponseHandler::CreateInstanceResponseHandler(
       CIMCreateInstanceRequestMessage* request,
       CIMCreateInstanceResponseMessage* response,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
   {
   }
   
   void CreateInstanceResponseHandler::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);
       }
   
       if(SimpleObjectPathResponseHandler::size() != 0)
       {
           MessageLoaderParms message(
               "Server.OperationResponseHandler.TOO_MANY_OBJECTS_DELIVERED",
               "Too many objects delivered.");
   
           throw CIMException(CIM_ERR_FAILED, message);
       }
   
       SimpleObjectPathResponseHandler::deliver(cimObjectPath);
   }
   
   void CreateInstanceResponseHandler::complete(void)
   {
       if(SimpleObjectPathResponseHandler::size() == 0)
       {
           MessageLoaderParms message(
               "Server.OperationResponseHandler.TOO_FEW_OBJECTS_DELIVERED",
               "Too few objects delivered.");
   
           throw CIMException(CIM_ERR_FAILED, message);
       }
   
       SimpleObjectPathResponseHandler::complete();
   }
   
   String CreateInstanceResponseHandler::getClass(void) const
   {
       return(String("CreateInstanceResponseHandler"));
   }
   
   #if 0
   // ATTN: is it an error to not return instance name?
   void CreateInstanceResponseHandler::validate(void)
   {
       if(getResponseObjectTotal() == 0)
       {
           setStatus(CIM_ERR_NOT_FOUND);
       }
   }
   #endif
   
   void CreateInstanceResponseHandler::transfer(void)
   {
       if(size() > 0)
       {
           CIMCreateInstanceResponseMessage & msg =
               *static_cast<CIMCreateInstanceResponseMessage *>(getResponse());
   
           msg.instanceName = getObjects()[0];
       }
   }
   
   //
   // ModifyInstanceResponseHandler
   //
   
   ModifyInstanceResponseHandler::ModifyInstanceResponseHandler(
       CIMModifyInstanceRequestMessage* request,
       CIMModifyInstanceResponseMessage* response,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
   {
   }
   
   String ModifyInstanceResponseHandler::getClass(void) const
   {
       return(String("ModifyInstanceResponseHandler"));
   }
   
   //
   // DeleteInstanceResponseHandler
   //
   
   DeleteInstanceResponseHandler::DeleteInstanceResponseHandler(
       CIMDeleteInstanceRequestMessage* request,
       CIMDeleteInstanceResponseMessage* response,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
   {
   }
   
   String DeleteInstanceResponseHandler::getClass(void) const
   {
       return(String("DeleteInstanceResponseHandler"));
   }
   
   //
   // GetPropertyResponseHandler
   //
   
   GetPropertyResponseHandler::GetPropertyResponseHandler(
       CIMGetPropertyRequestMessage* request,
       CIMGetPropertyResponseMessage* response,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
   {
   }
   
   void GetPropertyResponseHandler::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);
   }
   
   String GetPropertyResponseHandler::getClass(void) const
   {
       return(String("GetPropertyResponseHandler"));
   }
   
   void GetPropertyResponseHandler::transfer(void)
   {
       if(size() > 0)
       {
           CIMGetPropertyResponseMessage & msg =
               *static_cast<CIMGetPropertyResponseMessage *>(getResponse());
   
           msg.value = getObjects()[0];
       }
   }
   
   void GetPropertyResponseHandler::validate(void)
   {
       // error? provider claims success,
       // but did not deliver an instance.
       if(getResponseObjectTotal() == 0)
       {
           setStatus(CIM_ERR_NOT_FOUND);
       }
   }
   
   //
   // SetPropertyResponseHandler
   //
   
   SetPropertyResponseHandler::SetPropertyResponseHandler(
       CIMSetPropertyRequestMessage* request,
       CIMSetPropertyResponseMessage* response,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
   {
   }
   
   String SetPropertyResponseHandler::getClass(void) const
   {
       return(String("SetPropertyResponseHandler"));
   }
   
   //
   // ExecQueryResponseHandler
   //
   
   ExecQueryResponseHandler::ExecQueryResponseHandler(
       CIMExecQueryRequestMessage* request,
       CIMExecQueryResponseMessage* response,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
   {
   }
   
   void ExecQueryResponseHandler::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);
   }
   
   String ExecQueryResponseHandler::getClass(void) const
   {
       return(String("ExecQueryResponseHandler"));
   }
   
   void ExecQueryResponseHandler::transfer(void)
   {
       CIMExecQueryResponseMessage & msg =
           *static_cast<CIMExecQueryResponseMessage *>(getResponse());
   
       msg.cimObjects = getObjects();
   }
   
   Boolean ExecQueryResponseHandler::isAsync(void) const
   {
       return(false);
   }
   
   //
   // AssociatorsResponseHandler
   //
   
   AssociatorsResponseHandler::AssociatorsResponseHandler(
       CIMAssociatorsRequestMessage* request,
       CIMAssociatorsResponseMessage* response,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
   {
   }
   
   void AssociatorsResponseHandler::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);
   }
   
   String AssociatorsResponseHandler::getClass(void) const
   {
       return(String("AssociatorsResponseHandler"));
   }
   
   void AssociatorsResponseHandler::transfer(void)
   {
       CIMAssociatorsResponseMessage & msg =
           *static_cast<CIMAssociatorsResponseMessage *>(getResponse());
   
       msg.cimObjects = getObjects();
   }
   
   //
   // AssociatorNamesResponseHandler
   //
   
   AssociatorNamesResponseHandler::AssociatorNamesResponseHandler(
       CIMAssociatorNamesRequestMessage* request,
       CIMAssociatorNamesResponseMessage* response,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
   {
   }
   
   void AssociatorNamesResponseHandler::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);
   }
   
   String AssociatorNamesResponseHandler::getClass(void) const
   {
       return(String("AssociatorNamesResponseHandler"));
   }
   
   void AssociatorNamesResponseHandler::transfer(void)
   {
       CIMAssociatorNamesResponseMessage & msg =
           *static_cast<CIMAssociatorNamesResponseMessage *>(getResponse());
   
       msg.objectNames = getObjects();
   }
   
   //
   // ReferencesResponseHandler
   //
   
   ReferencesResponseHandler::ReferencesResponseHandler(
       CIMReferencesRequestMessage* request,
       CIMReferencesResponseMessage* response,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
   {
   }
   
   void ReferencesResponseHandler::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);
   }
   
   String ReferencesResponseHandler::getClass(void) const
   {
       return(String("ReferencesResponseHandler"));
   }
   
   void ReferencesResponseHandler::transfer(void)
   {
       CIMReferencesResponseMessage & msg =
           *static_cast<CIMReferencesResponseMessage *>(getResponse());
   
       msg.cimObjects = getObjects();
   }
   
   //
   // ReferenceNamesResponseHandler
   //
   
   ReferenceNamesResponseHandler::ReferenceNamesResponseHandler(
       CIMReferenceNamesRequestMessage* request,
       CIMReferenceNamesResponseMessage* response,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
   {
   }
   
   void ReferenceNamesResponseHandler::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);
   }
   
   String ReferenceNamesResponseHandler::getClass(void) const
   {
       return(String("ReferenceNamesResponseHandler"));
   }
   
   void ReferenceNamesResponseHandler::transfer(void)
   {
       CIMReferenceNamesResponseMessage & msg =
           *static_cast<CIMReferenceNamesResponseMessage *>(getResponse());
   
       msg.objectNames = getObjects();
   }
   
   //
   // InvokeMethodResponseHandler
   //
   
   InvokeMethodResponseHandler::InvokeMethodResponseHandler(
       CIMInvokeMethodRequestMessage* request,
       CIMInvokeMethodResponseMessage* response,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback)
   {
   }
   
   void InvokeMethodResponseHandler::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);
   }
   
   void InvokeMethodResponseHandler::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);
   }
   
   String InvokeMethodResponseHandler::getClass(void) const
   {
       return(String("InvokeMethodResponseHandler"));
   }
   
   void InvokeMethodResponseHandler::transfer(void)
   {
       CIMInvokeMethodResponseMessage & msg =
           *static_cast<CIMInvokeMethodResponseMessage *>(getResponse());
   
       msg.outParameters = getParamValues();
   
       // 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
       // virtual size, which refers to out parameters!
       msg.retValue = getReturnValue();
   }
   
   //
   // EnableIndicationsResponseHandler
   //
   
   EnableIndicationsResponseHandler::EnableIndicationsResponseHandler(
       CIMRequestMessage* request,
       CIMResponseMessage* response,
       const CIMInstance& provider,
       PEGASUS_INDICATION_CALLBACK_T indicationCallback,
       PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)
       : OperationResponseHandler(request, response, responseChunkCallback),
         _indicationCallback(indicationCallback)
   {
       _provider = provider;
   }
   
   void EnableIndicationsResponseHandler::deliver(const CIMIndication & cimIndication)
   {
       OperationContext context;
   
       Array<CIMObjectPath> subscriptionInstanceNames;
   
       context.insert(SubscriptionInstanceNamesContainer(subscriptionInstanceNames));
   
       deliver(context, cimIndication);
   }
   
   void EnableIndicationsResponseHandler::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
       CIMInstance cimInstance(cimIndication);
   
       //  Get list of subscription instance names from context
       Array<CIMObjectPath> subscriptionInstanceNames;
   
       if(context.contains(SubscriptionInstanceNamesContainer::NAME))
       {
           SubscriptionInstanceNamesContainer container =
               context.get(SubscriptionInstanceNamesContainer::NAME);
   
           subscriptionInstanceNames = container.getInstanceNames();
       }
       else
       {
           subscriptionInstanceNames.clear();
       }
   
       // l10n
       ContentLanguageList contentLangs;
   
       if(context.contains(ContentLanguageListContainer::NAME))
       {
           // Get the Content-Language for this indication.  The provider
           // does not have to add specify a language for the indication.
           ContentLanguageListContainer langContainer =
               context.get(ContentLanguageListContainer::NAME);
   
           contentLangs = langContainer.getLanguages();
       }
       else
       {
           // The provider did not explicitly set a Content-Language for
           // the indication.  Fall back to the lang set in this object.
           contentLangs = getLanguages();
       }
       // l10n -end
   
       // create message
       // l10n
       CIMProcessIndicationRequestMessage * request =
           new CIMProcessIndicationRequestMessage(
           XmlWriter::getNextMessageId(),
           cimInstance.getPath().getNameSpace(),
           cimInstance,
           subscriptionInstanceNames,
           _provider,
           QueueIdStack());  // Must be filled in by the callback function
   
       request->operationContext = context;
   
       if(request->operationContext.contains(ContentLanguageListContainer::NAME))
       {
           request->operationContext.set(ContentLanguageListContainer(contentLangs));
       }
       else
       {
           request->operationContext.insert(ContentLanguageListContainer(contentLangs));
       }
   
       _indicationCallback(request);
   }
   
   void EnableIndicationsResponseHandler::deliver(const Array<CIMIndication> & cimIndications)
   {
       OperationContext context;
   
       deliver(context, cimIndications);
   }
   
   void EnableIndicationsResponseHandler::deliver(const OperationContext & context, const Array<CIMIndication> & cimIndications)
   {
       for(Uint32 i = 0, n = cimIndications.size(); i < n; i++)
       {
           deliver(context, cimIndications[i]);
       }
   }
   
   String EnableIndicationsResponseHandler::getClass(void) const
   {
       return(String("EnableIndicationsResponseHandler"));
   }
   
   Boolean EnableIndicationsResponseHandler::isAsync(void) const
   {
       return(false);
   }
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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