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

Diff for /pegasus/src/Pegasus/Common/CimomMessage.cpp between version 1.30 and 1.38

version 1.30, 2008/09/17 05:57:05 version 1.38, 2010/07/02 09:26:31
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.  
 // 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
 // of this software and associated documentation files (the "Software"), to  // copy of this software and associated documentation files (the "Software"),
 // deal in the Software without restriction, including without limitation the  // to deal in the Software without restriction, including without limitation
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // sell copies of the Software, and to permit persons to whom the Software is  // and/or sell copies of the Software, and to permit persons to whom the
 // furnished to do so, subject to the following conditions:  // Software is furnished to do so, subject to the following conditions:
 // //
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  // The above copyright notice and this permission notice shall be included
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  // in all copies or substantial portions of the Software.
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT  
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR  
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT  
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN  
 // 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.  
 // //
 //==============================================================================  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 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.
   //
   //////////////////////////////////////////////////////////////////////////
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 36 
Line 34 
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 const Uint32 async_results::OK =                        0x00000000; const Uint32 async_results::OK =                        0x00000000;
 const Uint32 async_results::PARAMETER_ERROR =           0x00000001;  const Uint32 async_results::CIM_NAK =                   0x00000001;
 const Uint32 async_results::MODULE_ALREADY_REGISTERED = 0x00000002;  const Uint32 async_results::CIM_SERVICE_STOPPED =       0x00000002;
 const Uint32 async_results::MODULE_NOT_FOUND =          0x00000003;  
 const Uint32 async_results::INTERNAL_ERROR =            0x00000004;  
   
 const Uint32 async_results::ASYNC_STARTED =             0x00000005;  
 const Uint32 async_results::ASYNC_PROCESSING =          0x00000006;  
 const Uint32 async_results::ASYNC_COMPLETE =            0x00000007;  
 const Uint32 async_results::ASYNC_CANCELLED =           0x00000008;  
 const Uint32 async_results::ASYNC_PAUSED =              0x00000009;  
 const Uint32 async_results::ASYNC_RESUMED =             0x0000000a;  
   
 const Uint32 async_results::CIM_SERVICE_STARTED =       0x0000000b;  
 const Uint32 async_results::CIM_SERVICE_STOPPED  =      0x0000000c;  
   
 const Uint32 async_results::CIM_SERVICE_PAUSED  =       0x0000000d;  
 const Uint32 async_results::CIM_SERVICE_RESUMED =       0x0000000e;  
 const Uint32 async_results::CIM_NAK =                   0x0000000f;  
   
 const Uint32 async_results::ASYNC_PHASE_COMPLETE =      0x00000010;  
 const Uint32 async_results::ASYNC_CHILD_COMPLETE =      0x00000011;  
 const Uint32 async_results::ASYNC_PHASE_STARTED =       0x00000012;  
 const Uint32 async_results::ASYNC_CHILD_STARTED =       0x00000013;  
 const Uint32 async_results::CIM_PAUSED =                0x00000014;  
 const Uint32 async_results::CIM_STOPPED =               0x00000015;  
  
  
 AsyncMessage::AsyncMessage( AsyncMessage::AsyncMessage(
Line 77 
Line 52 
     MessageType type,     MessageType type,
     Uint32 mask,     Uint32 mask,
     AsyncOpNode* operation,     AsyncOpNode* operation,
     Uint32 destination,      Uint32 destination)
     Uint32 response,  
     Boolean blocking)  
     : AsyncMessage(     : AsyncMessage(
           type, destination, mask | MessageMask::ha_request, operation),            type, destination, mask | MessageMask::ha_request, operation)
       resp(response),  
       block(blocking)  
 { {
     if (op != 0)     if (op != 0)
         op->setRequest(this);         op->setRequest(this);
Line 93 
Line 64 
     MessageType type,     MessageType type,
     Uint32 mask,     Uint32 mask,
     AsyncOpNode* operation,     AsyncOpNode* operation,
     Uint32 resultCode,      Uint32 resultCode)
     Uint32 destination,  
     Boolean blocking)  
     : AsyncMessage(     : AsyncMessage(
           type, destination, mask | MessageMask::ha_reply, operation),            type,0, mask | MessageMask::ha_reply, operation),
       result(resultCode),        result(resultCode)
       block(blocking)  
 { {
     if (op != 0)     if (op != 0)
         op->setResponse(this);         op->setResponse(this);
 } }
  
 RegisterCimService::RegisterCimService(  AsyncIoClose::AsyncIoClose(
     AsyncOpNode* operation,  
     Boolean blocking,  
     const String& serviceName,  
     Uint32 serviceCapabilities,  
     Uint32 serviceMask,  
     Uint32 serviceQueue)  
     : AsyncRequest(  
           ASYNC_REGISTER_CIM_SERVICE,  
           0, operation, CIMOM_Q_ID,  
           serviceQueue, blocking),  
       name(serviceName),  
       capabilities(serviceCapabilities),  
       mask(serviceMask),  
       queue(serviceQueue)  
 {  
 }  
   
   
 DeRegisterCimService::DeRegisterCimService(  
     AsyncOpNode* operation,  
     Boolean blocking,  
     Uint32 serviceQueue)  
     : AsyncRequest(  
           ASYNC_DEREGISTER_CIM_SERVICE,  
           0, operation, CIMOM_Q_ID,  
           serviceQueue, blocking),  
       queue(serviceQueue)  
 {  
 }  
   
   
 UpdateCimService::UpdateCimService(  
     AsyncOpNode* operation,     AsyncOpNode* operation,
     Boolean blocking,      Uint32 destination)
     Uint32 serviceQueue,  
     Uint32 serviceCapabilities,  
     Uint32 serviceMask)  
     : AsyncRequest(     : AsyncRequest(
           ASYNC_UPDATE_CIM_SERVICE,            ASYNC_IOCLOSE,
           0, operation, CIMOM_Q_ID,  
           serviceQueue, blocking),  
       queue(serviceQueue),  
       capabilities(serviceCapabilities),  
       mask(serviceMask)  
 {  
 }  
   
 RegisteredModule::RegisteredModule(  
     AsyncOpNode* operation,  
     Boolean blocking,  
     Uint32 serviceQueue,  
     const String& newModule)  
     : AsyncRequest(  
           ASYNC_REGISTERED_MODULE,  
           0,           0,
           operation,           operation,
           CIMOM_Q_ID,            destination)
           serviceQueue,  
           blocking),  
       _module(newModule)  
 {  
 }  
   
 DeRegisteredModule::DeRegisteredModule(  
     AsyncOpNode* operation,  
     Boolean blocking,  
     Uint32 serviceQueue,  
     const String& removedModule)  
     : AsyncRequest(  
           ASYNC_DEREGISTERED_MODULE,  
           0,  
           operation,  
           CIMOM_Q_ID,  
           serviceQueue,  
           blocking),  
       _module(removedModule)  
 {  
 }  
   
   
 FindModuleInService::FindModuleInService(  
     AsyncOpNode* operation,  
     Boolean blocking,  
     Uint32 responseQueue,  
     const String& module)  
     : AsyncRequest(  
           ASYNC_FIND_MODULE_IN_SERVICE,  
           0,  
           operation,  
           CIMOM_Q_ID,  
           responseQueue,  
           blocking),  
       _module(module)  
 {  
 }  
   
 FindModuleInServiceResponse::FindModuleInServiceResponse(  
     AsyncOpNode* operation,  
     Uint32 resultCode,  
     Uint32 destination,  
     Boolean blocking,  
     Uint32 moduleServiceQueue)  
     : AsyncReply(  
           ASYNC_FIND_MODULE_IN_SERVICE_RESPONSE,  
           0,  
           operation,  
           resultCode,  
           destination,  
           blocking),  
       _module_service_queue(moduleServiceQueue)  
 {  
 }  
   
 AsyncIoctl::AsyncIoctl(  
     AsyncOpNode* operation,  
     Uint32 destination,  
     Uint32 response,  
     Boolean blocking,  
     Uint32 code,  
     Uint32 intParam,  
     void* pParam)  
     : AsyncRequest(  
           ASYNC_IOCTL,  
           0, operation,  
           destination, response, blocking),  
       ctl(code),  
       intp(intParam),  
       voidp(pParam)  
 { {
 } }
  
   
 CimServiceStart::CimServiceStart( CimServiceStart::CimServiceStart(
     AsyncOpNode* operation,     AsyncOpNode* operation,
     Uint32 destination,      Uint32 destination)
     Uint32 response,  
     Boolean blocking)  
     : AsyncRequest(     : AsyncRequest(
           ASYNC_CIMSERVICE_START,           ASYNC_CIMSERVICE_START,
           0, operation, destination,            0, operation, destination)
           response, blocking)  
 { {
 } }
  
  
 CimServiceStop::CimServiceStop( CimServiceStop::CimServiceStop(
     AsyncOpNode* operation,     AsyncOpNode* operation,
     Uint32 destination,      Uint32 destination)
     Uint32 response,  
     Boolean blocking)  
     : AsyncRequest(     : AsyncRequest(
           ASYNC_CIMSERVICE_STOP,           ASYNC_CIMSERVICE_STOP,
           0, operation, destination,            0, operation, destination)
           response, blocking)  
 {  
 }  
   
   
 CimServicePause::CimServicePause(  
     AsyncOpNode* operation,  
     Uint32 destination,  
     Uint32 response,  
     Boolean blocking)  
     : AsyncRequest(  
           ASYNC_CIMSERVICE_PAUSE,  
           0, operation, destination,  
           response, blocking)  
 {  
 }  
   
   
 CimServiceResume::CimServiceResume(  
     AsyncOpNode* operation,  
     Uint32 destination,  
     Uint32 response,  
     Boolean blocking)  
     : AsyncRequest(  
           ASYNC_CIMSERVICE_RESUME,  
           0, operation, destination,  
           response, blocking)  
 { {
 } }
  
 AsyncOperationStart::AsyncOperationStart( AsyncOperationStart::AsyncOperationStart(
     AsyncOpNode* operation,     AsyncOpNode* operation,
     Uint32 destination,     Uint32 destination,
     Uint32 response,  
     Boolean blocking,  
     Message* action)     Message* action)
     : AsyncRequest(     : AsyncRequest(
           ASYNC_ASYNC_OP_START,           ASYNC_ASYNC_OP_START,
           0,           0,
           operation,           operation,
           destination, response, blocking),            destination),
       _act(action)       _act(action)
 { {
 } }
Line 314 
Line 126 
  
 AsyncOperationResult::AsyncOperationResult( AsyncOperationResult::AsyncOperationResult(
     AsyncOpNode* operation,     AsyncOpNode* operation,
     Uint32 resultCode,      Uint32 resultCode)
     Uint32 destination,  
     Boolean blocking)  
     : AsyncReply(     : AsyncReply(
           ASYNC_ASYNC_OP_RESULT,           ASYNC_ASYNC_OP_RESULT,
           0,           0,
           operation,           operation,
           resultCode,            resultCode)
           destination,  
           blocking)  
 { {
 } }
  
Line 331 
Line 139 
 AsyncModuleOperationStart::AsyncModuleOperationStart( AsyncModuleOperationStart::AsyncModuleOperationStart(
     AsyncOpNode* operation,     AsyncOpNode* operation,
     Uint32 destination,     Uint32 destination,
     Uint32 response,  
     Boolean blocking,  
     const String& targetModule,     const String& targetModule,
     Message* action)     Message* action)
     : AsyncRequest(     : AsyncRequest(
           ASYNC_ASYNC_MODULE_OP_START,           ASYNC_ASYNC_MODULE_OP_START,
           0,           0,
           operation,           operation,
           destination,            destination),
           response,  
           blocking),  
       _target_module(targetModule),       _target_module(targetModule),
       _act(action)       _act(action)
 { {
Line 360 
Line 164 
 AsyncModuleOperationResult::AsyncModuleOperationResult( AsyncModuleOperationResult::AsyncModuleOperationResult(
     AsyncOpNode* operation,     AsyncOpNode* operation,
     Uint32 resultCode,     Uint32 resultCode,
     Uint32 destination,  
     Boolean blocking,  
     const String& targetModule,     const String& targetModule,
     Message* result)     Message* result)
     : AsyncReply(     : AsyncReply(
           ASYNC_ASYNC_MODULE_OP_RESULT,           ASYNC_ASYNC_MODULE_OP_RESULT,
           0,           0,
           operation, resultCode, destination,            operation, resultCode),
           blocking),  
       _targetModule(targetModule),       _targetModule(targetModule),
       _res(result)       _res(result)
 { {
Line 391 
Line 192 
     : AsyncRequest(     : AsyncRequest(
           ASYNC_ASYNC_LEGACY_OP_START,           ASYNC_ASYNC_LEGACY_OP_START,
           0,           0,
           operation, destination, CIMOM_Q_ID, false),            operation, destination),
       _act(action)       _act(action)
 { {
     _act->put_async(this);     _act->put_async(this);
Line 407 
Line 208 
  
 } }
  
   void AsyncLegacyOperationStart::put_action(Message *act_)
   {
       _act = act_;
   }
   
 AsyncLegacyOperationResult::AsyncLegacyOperationResult( AsyncLegacyOperationResult::AsyncLegacyOperationResult(
     AsyncOpNode* operation,     AsyncOpNode* operation,
     Message* result)     Message* result)
     : AsyncReply(     : AsyncReply(
           ASYNC_ASYNC_LEGACY_OP_RESULT,           ASYNC_ASYNC_LEGACY_OP_RESULT,
           0, operation,            0, operation, 0),
           0, CIMOM_Q_ID, false),  
       _res(result)       _res(result)
 { {
     _res->put_async(this);     _res->put_async(this);
Line 427 
Line 232 
     return ret;     return ret;
 } }
  
 FindServiceQueue::FindServiceQueue(  
     AsyncOpNode* operation,  
     Uint32 response,  
     Boolean blocking,  
     const String& serviceName,  
     Uint32 serviceCapabilities,  
     Uint32 serviceMask)  
     : AsyncRequest(  
           ASYNC_FIND_SERVICE_Q,  
           0, operation,  
           CIMOM_Q_ID,  
           response,  
           blocking),  
       name(serviceName),  
       capabilities(serviceCapabilities),  
       mask(serviceMask)  
 {  
 }  
   
   
 FindServiceQueueResult::FindServiceQueueResult(  
     AsyncOpNode* operation,  
     Uint32 resultCode,  
     Uint32 destination,  
     Boolean blocking,  
     Array<Uint32> queueIds)  
     : AsyncReply(  
           ASYNC_FIND_SERVICE_Q_RESULT,  
           0, operation,  
           resultCode, destination, blocking),  
       qids(queueIds)  
 {  
 }  
   
 EnumerateService::EnumerateService(  
     AsyncOpNode* operation,  
     Uint32 response,  
     Boolean blocking,  
     Uint32 queueId)  
     : AsyncRequest(  
           ASYNC_ENUMERATE_SERVICE,  
           0,  
           operation,  
           CIMOM_Q_ID,  
           response,  
           blocking),  
       qid(queueId)  
 {  
 }  
   
 EnumerateServiceResponse::EnumerateServiceResponse(  
     AsyncOpNode* operation,  
     Uint32 resultCode,  
     Uint32 response,  
     Boolean blocking,  
     const String& serviceName,  
     Uint32 serviceCapabilities,  
     Uint32 serviceMask,  
     Uint32 serviceQid)  
     : AsyncReply(  
           ASYNC_ENUMERATE_SERVICE_RESULT,  
           0,  
           operation,  
           resultCode,  
           response,  
           blocking),  
       name(serviceName),  
       capabilities(serviceCapabilities),  
       mask(serviceMask),  
       qid(serviceQid)  
 {  
 }  
   
 AsyncMessage::~AsyncMessage() AsyncMessage::~AsyncMessage()
 { {
 } }

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