(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.1 and 1.19

version 1.1, 2004/03/04 09:55:38 version 1.19, 2006/08/30 20:42:30
Line 1 
Line 1 
 //%2003////////////////////////////////////////////////////////////////////////  //%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.
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
 // 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.;
   // 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 26 
Line 32 
 // Author: Chip Vincent (cvincent@us.ibm.com) // Author: Chip Vincent (cvincent@us.ibm.com)
 // //
 // Modified By: // Modified By:
   //         Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase2
   //         Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "OperationResponseHandler.h" #include "OperationResponseHandler.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::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
    #define PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD 100
   #elif PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD  == 0
    #undef PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD
    #define PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD  ~0
   #endif
   
       if (!request)
       {
           _responseObjectThreshold = ~0;
       }
           else
       {
           _responseObjectThreshold = PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD;
   
   #ifdef PEGASUS_DEBUG
               static const char *responseObjectThreshold =
                       getenv("PEGASUS_RESPONSE_OBJECT_COUNT_THRESHOLD");
   
           if (responseObjectThreshold)
               {
                       Uint32 i = (Uint32)atoi(responseObjectThreshold);
   
               if (i > 0)
               {
                   _responseObjectThreshold = i;
               }
               }
   #endif
       }
   }
   
   OperationResponseHandler::~OperationResponseHandler()
   {
           _request = 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
   // class because all asyncronous response must have a "response" pointer
   // to go through. Only operation classes have a response pointer
   void OperationResponseHandler::send(Boolean isComplete)
   {
           // some handlers do not send async because their callers cannot handle
           // partial responses. If this is the case, stop here.
   
           if (isAsync() == false)
           {
                   // preserve tradional behavior
                   if (isComplete == true)
           {
               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;
           }
   
           SimpleResponseHandler &simple = *simpleP;
           PEGASUS_ASSERT(_response);
           Uint32 objectCount = simple.size();
   
           // have not reached threshold yet
           if ((isComplete == false) && (objectCount < _responseObjectThreshold))
       {
           return;
       }
   
           CIMResponseMessage *response = _response;
   
           // for complete responses, just use the one handed down from caller
           // otherwise, create our own that the caller never sees but is
           // utilized for async responses underneath
   
           if (isComplete == false)
       {
           _response = _request->buildResponse();
       }
   
           _response->setComplete(isComplete);
           _responseObjectTotal += objectCount;
   
           // since we are reusing response for every chunk,keep track of original count
           _response->setIndex(_responseMessageTotal++);
   
           // set the originally allocated response to one more than the current.
           // The reason for doing this is proactive in case of an exception. This
           // allows the last response to be set as it may not re-enter this code.
   
           if (isComplete == false)
       {
           response->setIndex(_responseMessageTotal);
       }
   
           validate();
   
           if (_response->cimException.getCode() != CIM_ERR_SUCCESS)
       {
           simple.clear();
       }
   
           String function = getClass() + "::" + "transfer";
           Logger::put(
           Logger::STANDARD_LOG,
           System::CIMSERVER,
           Logger::TRACE,
           function);
   
           transfer();
           simple.clear();
   
           // l10n
           _response->operationContext.set(ContentLanguageListContainer(simple.getLanguages()));
   
           // call thru ProviderManager to get externally declared entry point
   
           if (isComplete == false)
           {
               _responseChunkCallback(_request, _response);
           }
   
           // put caller's allocated response back in place. Note that _response
           // is INVALID after sending because it has been deleted externally
   
           _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.1  
changed lines
  Added in v.1.19
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2