(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.24.12.1 and 1.33.2.7

version 1.24.12.1, 2008/09/19 06:30:28 version 1.33.2.7, 2009/12/08 13:59:37
Line 1 
Line 1 
 //%2006////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development  // Licensed to The Open Group (TOG) under one or more contributor license
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.  // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;  // this work for additional information regarding copyright ownership.
 // IBM Corp.; EMC Corporation, The Open Group.  // Each contributor licenses this file to you under the OpenPegasus Open
 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;  // Source License; you may not use this file except in compliance with the
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.  // License.
 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;  //
 // EMC Corporation; VERITAS Software Corporation; The Open Group.  // Permission is hereby granted, free of charge, to any person obtaining a
 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;  // copy of this software and associated documentation files (the "Software"),
 // EMC Corporation; Symantec Corporation; The Open Group.  // to deal in the Software without restriction, including without limitation
 //  // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // Permission is hereby granted, free of charge, to any person obtaining a copy  // and/or sell copies of the Software, and to permit persons to whom the
 // of this software and associated documentation files (the "Software"), to  // Software is furnished to do so, subject to the following conditions:
 // deal in the Software without restriction, including without limitation the  //
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  // The above copyright notice and this permission notice shall be included
 // sell copies of the Software, and to permit persons to whom the Software is  // in all copies or substantial portions of the Software.
 // furnished to do so, subject to the following conditions:  //
 //  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT  // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR  // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT  // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN  // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION  
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  
 // //
 //==============================================================================  //////////////////////////////////////////////////////////////////////////
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "OperationResponseHandler.h" #include "OperationResponseHandler.h"
 #include "CIMOMHandleContext.h" #include "CIMOMHandleContext.h"
  
 #include <Pegasus/Common/Logger.h>  #include <Pegasus/Common/Tracer.h>
 #include <Pegasus/Common/SharedPtr.h> #include <Pegasus/Common/SharedPtr.h>
 #include <Pegasus/Provider/CIMOMHandle.h> #include <Pegasus/Provider/CIMOMHandle.h>
 #include <Pegasus/Config/ConfigManager.h> #include <Pegasus/Config/ConfigManager.h>
Line 52 
Line 50 
     if (request->operationContext.contains(     if (request->operationContext.contains(
             CachedClassDefinitionContainer::NAME))             CachedClassDefinitionContainer::NAME))
     {     {
         CIMClass cimClass;  
         CachedClassDefinitionContainer container =         CachedClassDefinitionContainer container =
             request->operationContext.get(             request->operationContext.get(
                 CachedClassDefinitionContainer::NAME);                 CachedClassDefinitionContainer::NAME);
         cimClass = container.getClass();          CIMClass cimClass = container.getClass().clone();
           container = CachedClassDefinitionContainer(cimClass);
         SharedPtr<NormalizerContext> tmpContext(new CIMOMHandleContext());         SharedPtr<NormalizerContext> tmpContext(new CIMOMHandleContext());
         ObjectNormalizer tmpNormalizer(         ObjectNormalizer tmpNormalizer(
             cimClass,             cimClass,
Line 250 
Line 248 
         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();
Line 357 
Line 354 
         _normalizer.processInstance(localInstance));         _normalizer.processInstance(localInstance));
 } }
  
   void GetInstanceResponseHandler::deliver(const SCMOInstance& 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);
       }
   
       SimpleInstanceResponseHandler::deliver(cimInstance);
   }
   
 void GetInstanceResponseHandler::complete() void GetInstanceResponseHandler::complete()
 { {
     if (SimpleInstanceResponseHandler::size() == 0)     if (SimpleInstanceResponseHandler::size() == 0)
Line 383 
Line 403 
     {     {
         CIMGetInstanceResponseMessage& msg =         CIMGetInstanceResponseMessage& msg =
             *static_cast<CIMGetInstanceResponseMessage*>(getResponse());             *static_cast<CIMGetInstanceResponseMessage*>(getResponse());
           Array<CIMInstance> cimObjs= getObjects();
         msg.cimInstance = getObjects()[0];          Array<SCMOInstance> scmoObjs= getSCMOObjects();
           if (cimObjs.size() != 0)
           {
               msg.getResponseData().setInstance(cimObjs[0]);
           }
           else
           {
               msg.getResponseData().setSCMO(scmoObjs);
           }
     }     }
 } }
  
Line 430 
Line 458 
         _normalizer.processInstance(cimInstance));         _normalizer.processInstance(cimInstance));
 } }
  
   void EnumerateInstancesResponseHandler::deliver(
       const SCMOInstance& scmoInstance)
   {
       if (scmoInstance.isUninitialized())
       {
           MessageLoaderParms message(
               "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
               "The object is not initialized.");
   
           throw CIMException(CIM_ERR_FAILED, message);
       }
       SimpleInstanceResponseHandler::deliver(scmoInstance);
   }
   
 String EnumerateInstancesResponseHandler::getClass() const String EnumerateInstancesResponseHandler::getClass() const
 { {
     return String("EnumerateInstancesResponseHandler");     return String("EnumerateInstancesResponseHandler");
Line 440 
Line 482 
     CIMEnumerateInstancesResponseMessage& msg =     CIMEnumerateInstancesResponseMessage& msg =
         *static_cast<CIMEnumerateInstancesResponseMessage*>(getResponse());         *static_cast<CIMEnumerateInstancesResponseMessage*>(getResponse());
  
     msg.cimNamedInstances = getObjects();      Array<CIMInstance> cimObjs= getObjects();
       Array<SCMOInstance> scmoObjs= getSCMOObjects();
       if (cimObjs.size() != 0)
       {
           msg.getResponseData().setInstances(cimObjs);
       }
       if (scmoObjs.size() != 0)
       {
           msg.getResponseData().setSCMO(scmoObjs);
       }
 } }
  
 // //
Line 476 
Line 527 
         _normalizer.processInstanceObjectPath(cimObjectPath));         _normalizer.processInstanceObjectPath(cimObjectPath));
 } }
  
   void EnumerateInstanceNamesResponseHandler::deliver(
       const SCMOInstance& scmoObjectPath)
   {
       if (scmoObjectPath.getClassName()==NULL)
       {
           MessageLoaderParms message(
               "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
               "The object is not initialized.");
   
           throw CIMException(CIM_ERR_FAILED, message);
       }
   
       SimpleObjectPathResponseHandler::deliver(scmoObjectPath);
   }
   
 String EnumerateInstanceNamesResponseHandler::getClass() const String EnumerateInstanceNamesResponseHandler::getClass() const
 { {
     return String("EnumerateInstanceNamesResponseHandler");     return String("EnumerateInstanceNamesResponseHandler");
Line 486 
Line 552 
     CIMEnumerateInstanceNamesResponseMessage& msg =     CIMEnumerateInstanceNamesResponseMessage& msg =
         *static_cast<CIMEnumerateInstanceNamesResponseMessage*>(getResponse());         *static_cast<CIMEnumerateInstanceNamesResponseMessage*>(getResponse());
  
     msg.instanceNames = getObjects();      Array<CIMObjectPath> cimObjs= getObjects();
       Array<SCMOInstance> scmoObjs= getSCMOObjects();
       if (cimObjs.size() != 0)
       {
           msg.getResponseData().setInstanceNames(cimObjs);
       }
       if (scmoObjs.size() != 0)
       {
           msg.getResponseData().setSCMO(scmoObjs);
       }
 } }
  
 // //
Line 561 
Line 636 
         CIMCreateInstanceResponseMessage& msg =         CIMCreateInstanceResponseMessage& msg =
             *static_cast<CIMCreateInstanceResponseMessage*>(getResponse());             *static_cast<CIMCreateInstanceResponseMessage*>(getResponse());
  
         msg.instanceName = getObjects()[0];          Array<CIMObjectPath> cimObjs= getObjects();
           Array<SCMOInstance> scmoObjs= getSCMOObjects();
           if (cimObjs.size() != 0)
           {
               msg.instanceName = cimObjs[0];
           }
           else
           {
               scmoObjs[0].getCIMObjectPath(msg.instanceName);
           }
     }     }
 } }
  
Line 694 
Line 778 
     SimpleInstance2ObjectResponseHandler::deliver(cimInstance);     SimpleInstance2ObjectResponseHandler::deliver(cimInstance);
 } }
  
   void ExecQueryResponseHandler::deliver(const SCMOInstance& scmoInstance)
   {
       if (scmoInstance.isUninitialized())
       {
           MessageLoaderParms message(
               "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
               "The object is not initialized.");
   
           throw CIMException(CIM_ERR_FAILED, message);
       }
   
       SimpleInstance2ObjectResponseHandler::deliver(scmoInstance);
   }
   
 String ExecQueryResponseHandler::getClass() const String ExecQueryResponseHandler::getClass() const
 { {
     return String("ExecQueryResponseHandler");     return String("ExecQueryResponseHandler");
Line 704 
Line 802 
     CIMExecQueryResponseMessage& msg =     CIMExecQueryResponseMessage& msg =
         *static_cast<CIMExecQueryResponseMessage*>(getResponse());         *static_cast<CIMExecQueryResponseMessage*>(getResponse());
  
     msg.cimObjects = getObjects();      Array<CIMObject> cimObjs= getObjects();
       Array<SCMOInstance> scmoObjs= getSCMOObjects();
       if (cimObjs.size() != 0)
       {
           msg.getResponseData().setObjects(cimObjs);
       }
       if (scmoObjs.size() != 0)
       {
           msg.getResponseData().setSCMO(scmoObjs);
       }
 } }
  
 Boolean ExecQueryResponseHandler::isAsync() const Boolean ExecQueryResponseHandler::isAsync() const
Line 738 
Line 845 
     SimpleObjectResponseHandler::deliver(cimObject);     SimpleObjectResponseHandler::deliver(cimObject);
 } }
  
   void AssociatorsResponseHandler::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);
       }
   
       SimpleObjectResponseHandler::deliver(cimInstance);
   }
   
   void AssociatorsResponseHandler::deliver(const SCMOInstance& scmoObject)
   {
       if (scmoObject.isUninitialized())
       {
           MessageLoaderParms message(
               "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
               "The object is not initialized.");
   
           throw CIMException(CIM_ERR_FAILED, message);
       }
       SimpleObjectResponseHandler::deliver(scmoObject);
   }
   
 String AssociatorsResponseHandler::getClass() const String AssociatorsResponseHandler::getClass() const
 { {
     return String("AssociatorsResponseHandler");     return String("AssociatorsResponseHandler");
Line 748 
Line 882 
     CIMAssociatorsResponseMessage& msg =     CIMAssociatorsResponseMessage& msg =
         *static_cast<CIMAssociatorsResponseMessage*>(getResponse());         *static_cast<CIMAssociatorsResponseMessage*>(getResponse());
  
     msg.cimObjects = getObjects();      Array<CIMObject> cimObjs= getObjects();
       Array<SCMOInstance> scmoObjs= getSCMOObjects();
       if (cimObjs.size() != 0)
       {
           msg.getResponseData().setObjects(cimObjs);
       }
       if (scmoObjs.size() != 0)
       {
           msg.getResponseData().setSCMO(scmoObjs);
       }
 } }
  
 // //
Line 777 
Line 920 
     SimpleObjectPathResponseHandler::deliver(cimObjectPath);     SimpleObjectPathResponseHandler::deliver(cimObjectPath);
 } }
  
   void AssociatorNamesResponseHandler::deliver(const SCMOInstance& scmoObjectPath)
   {
       SimpleObjectPathResponseHandler::deliver(scmoObjectPath);
   }
   
 String AssociatorNamesResponseHandler::getClass() const String AssociatorNamesResponseHandler::getClass() const
 { {
     return String("AssociatorNamesResponseHandler");     return String("AssociatorNamesResponseHandler");
Line 787 
Line 935 
     CIMAssociatorNamesResponseMessage& msg =     CIMAssociatorNamesResponseMessage& msg =
         *static_cast<CIMAssociatorNamesResponseMessage*>(getResponse());         *static_cast<CIMAssociatorNamesResponseMessage*>(getResponse());
  
     msg.objectNames = getObjects();      Array<CIMObjectPath> cimObjs= getObjects();
       Array<SCMOInstance> scmoObjs= getSCMOObjects();
       if (cimObjs.size() != 0)
       {
           msg.getResponseData().setInstanceNames(cimObjs);
       }
       if (scmoObjs.size() != 0)
       {
           msg.getResponseData().setSCMO(scmoObjs);
       }
 } }
  
 // //
Line 816 
Line 973 
     SimpleObjectResponseHandler::deliver(cimObject);     SimpleObjectResponseHandler::deliver(cimObject);
 } }
  
   void ReferencesResponseHandler::deliver(const SCMOInstance& scmoObject)
   {
       if (scmoObject.isUninitialized())
       {
           MessageLoaderParms message(
               "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
               "The object is not initialized.");
   
           throw CIMException(CIM_ERR_FAILED, message);
       }
       SimpleObjectResponseHandler::deliver(scmoObject);
   }
   
 String ReferencesResponseHandler::getClass() const String ReferencesResponseHandler::getClass() const
 { {
     return String("ReferencesResponseHandler");     return String("ReferencesResponseHandler");
Line 826 
Line 996 
     CIMReferencesResponseMessage& msg =     CIMReferencesResponseMessage& msg =
         *static_cast<CIMReferencesResponseMessage*>(getResponse());         *static_cast<CIMReferencesResponseMessage*>(getResponse());
  
     msg.cimObjects = getObjects();      Array<CIMObject> cimObjs= getObjects();
       Array<SCMOInstance> scmoObjs= getSCMOObjects();
       if (cimObjs.size() != 0)
       {
           msg.getResponseData().setObjects(cimObjs);
       }
       if (scmoObjs.size() != 0)
       {
           msg.getResponseData().setSCMO(scmoObjs);
       }
 } }
  
 // //
Line 855 
Line 1034 
     SimpleObjectPathResponseHandler::deliver(cimObjectPath);     SimpleObjectPathResponseHandler::deliver(cimObjectPath);
 } }
  
   void ReferenceNamesResponseHandler::deliver(const SCMOInstance& scmoObjectPath)
   {
       SimpleObjectPathResponseHandler::deliver(scmoObjectPath);
   }
   
 String ReferenceNamesResponseHandler::getClass() const String ReferenceNamesResponseHandler::getClass() const
 { {
     return String("ReferenceNamesResponseHandler");     return String("ReferenceNamesResponseHandler");
Line 865 
Line 1049 
     CIMReferenceNamesResponseMessage& msg =     CIMReferenceNamesResponseMessage& msg =
         *static_cast<CIMReferenceNamesResponseMessage*>(getResponse());         *static_cast<CIMReferenceNamesResponseMessage*>(getResponse());
  
     msg.objectNames = getObjects();      Array<CIMObjectPath> cimObjs= getObjects();
       Array<SCMOInstance> scmoObjs= getSCMOObjects();
       if (cimObjs.size() != 0)
       {
           msg.getResponseData().setInstanceNames(cimObjs);
       }
       if (scmoObjs.size() != 0)
       {
           msg.getResponseData().setSCMO(scmoObjs);
       }
 } }
  
 // //

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