(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.25 and 1.26

version 1.25, 2006/07/26 20:34:00 version 1.26, 2006/08/15 18:08:45
Line 29 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Day (mdday@us.ibm.com)  
 //  
 // Modified By:  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "CimomMessage.h" #include "CimomMessage.h"
  
 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::PARAMETER_ERROR =           0x00000001;
 const Uint32 async_results::MODULE_ALREADY_REGISTERED = 0x00000002; const Uint32 async_results::MODULE_ALREADY_REGISTERED = 0x00000002;
 const Uint32 async_results::MODULE_NOT_FOUND =          0x00000003; const Uint32 async_results::MODULE_NOT_FOUND =          0x00000003;
 const Uint32 async_results::INTERNAL_ERROR =            0x00000004; const Uint32 async_results::INTERNAL_ERROR =            0x00000004;
  
   
 const Uint32 async_results::ASYNC_STARTED =             0x00000005; const Uint32 async_results::ASYNC_STARTED =             0x00000005;
 const Uint32 async_results::ASYNC_PROCESSING =          0x00000006; const Uint32 async_results::ASYNC_PROCESSING =          0x00000006;
 const Uint32 async_results::ASYNC_COMPLETE =            0x00000007; const Uint32 async_results::ASYNC_COMPLETE =            0x00000007;
Line 99 
Line 92 
 const Uint32 async_messages::ASYNC_MODULE_OP_RESULT  =  ASYNC_ASYNC_MODULE_OP_RESULT; const Uint32 async_messages::ASYNC_MODULE_OP_RESULT  =  ASYNC_ASYNC_MODULE_OP_RESULT;
  
  
   AsyncMessage::AsyncMessage(
 AsyncMessage::AsyncMessage(Uint32 type,      Uint32 type,
                            Uint32 destination,                            Uint32 destination,
                            Uint32 mask,                            Uint32 mask,
                            AsyncOpNode *operation)                            AsyncOpNode *operation)
    : Message(type, destination, mask | message_mask::ha_async),    : Message(type, destination, mask | message_mask::ha_async),
      op(operation)      op(operation)
 { {
   
 } }
  
 AsyncRequest::AsyncRequest(Uint32 type,  AsyncRequest::AsyncRequest(
       Uint32 type,
                            Uint32 mask,                            Uint32 mask,
                            AsyncOpNode *operation,                            AsyncOpNode *operation,
                            Uint32 destination,                            Uint32 destination,
                            Uint32 response,                            Uint32 response,
                            Boolean blocking)                            Boolean blocking)
    : AsyncMessage(type, destination, mask | message_mask::ha_request, operation),      : AsyncMessage(
             type, destination, mask | message_mask::ha_request, operation),
      resp(response),      resp(response),
      block(blocking)      block(blocking)
 { {
Line 124 
Line 118 
       op->setRequest(this);       op->setRequest(this);
 } }
  
 AsyncReply::AsyncReply(Uint32 type,  AsyncReply::AsyncReply(
       Uint32 type,
                        Uint32 mask,                        Uint32 mask,
                        AsyncOpNode *operation,                        AsyncOpNode *operation,
                        Uint32 result_code,      Uint32 resultCode,
                        Uint32 destination,                        Uint32 destination,
                        Boolean blocking)                        Boolean blocking)
    : AsyncMessage(type, destination, mask | message_mask::ha_reply, operation),      : AsyncMessage(
      result(result_code),            type, destination, mask | message_mask::ha_reply, operation),
         result(resultCode),
      block(blocking)      block(blocking)
 { {
    if( op != 0 )    if( op != 0 )
       op->setResponse(this);       op->setResponse(this);
 } }
  
   
   
   
 RegisterCimService::RegisterCimService( RegisterCimService::RegisterCimService(
                                        AsyncOpNode *operation,                                        AsyncOpNode *operation,
                                        Boolean blocking,                                        Boolean blocking,
                                        String service_name,      const String& serviceName,
                                        Uint32 service_capabilities,      Uint32 serviceCapabilities,
                                        Uint32 service_mask,      Uint32 serviceMask,
                                        Uint32 service_queue)      Uint32 serviceQueue)
    : AsyncRequest( async_messages::REGISTER_CIM_SERVICE,      : AsyncRequest(
             async_messages::REGISTER_CIM_SERVICE,
                    0, operation, CIMOM_Q_ID,                    0, operation, CIMOM_Q_ID,
                    service_queue, blocking),            serviceQueue, blocking),
      name(service_name),        name(serviceName),
      capabilities(service_capabilities),        capabilities(serviceCapabilities),
      mask(service_mask),        mask(serviceMask),
      queue(service_queue)        queue(serviceQueue)
 { {
   
 } }
  
  
 DeRegisterCimService::DeRegisterCimService( DeRegisterCimService::DeRegisterCimService(
                                            AsyncOpNode *operation,                                            AsyncOpNode *operation,
                                            Boolean blocking,                                            Boolean blocking,
                                            Uint32 service_queue)      Uint32 serviceQueue)
    : AsyncRequest( async_messages::DEREGISTER_CIM_SERVICE,      : AsyncRequest(
             async_messages::DEREGISTER_CIM_SERVICE,
                    0, operation, CIMOM_Q_ID,                    0, operation, CIMOM_Q_ID,
                    service_queue, blocking),            serviceQueue, blocking),
      queue(service_queue)        queue(serviceQueue)
 { {
   
 } }
  
  
   
 UpdateCimService::UpdateCimService( UpdateCimService::UpdateCimService(
                                    AsyncOpNode *operation,                                    AsyncOpNode *operation,
                                    Boolean blocking,                                    Boolean blocking,
                                    Uint32 service_queue,      Uint32 serviceQueue,
                                    Uint32 service_capabilities,      Uint32 serviceCapabilities,
                                    Uint32 service_mask)      Uint32 serviceMask)
    : AsyncRequest( async_messages::UPDATE_CIM_SERVICE,      : AsyncRequest(
             async_messages::UPDATE_CIM_SERVICE,
                    0, operation, CIMOM_Q_ID,                    0, operation, CIMOM_Q_ID,
                    service_queue, blocking),            serviceQueue, blocking),
      queue(service_queue),        queue(serviceQueue),
      capabilities(service_capabilities),        capabilities(serviceCapabilities),
      mask(service_mask)        mask(serviceMask)
 { {
   
 } }
  
 RegisteredModule::RegisteredModule( RegisteredModule::RegisteredModule(
                                    AsyncOpNode *operation,                                    AsyncOpNode *operation,
                                    Boolean blocking,                                    Boolean blocking,
                                    Uint32 service_queue,      Uint32 serviceQueue,
                                    String new_module)      const String& newModule)
    : AsyncRequest( async_messages::REGISTERED_MODULE,      : AsyncRequest(
             async_messages::REGISTERED_MODULE,
                    0,                    0,
                    operation,                    operation,
                    CIMOM_Q_ID,                    CIMOM_Q_ID,
                    service_queue,            serviceQueue,
                    blocking),                    blocking),
      _module(new_module)        _module(newModule)
 { {
   
 } }
  
 DeRegisteredModule::DeRegisteredModule( DeRegisteredModule::DeRegisteredModule(
                                      AsyncOpNode *operation,                                      AsyncOpNode *operation,
                                      Boolean blocking,                                      Boolean blocking,
                                      Uint32 service_queue,      Uint32 serviceQueue,
                                      String removed_module)      const String& removedModule)
    : AsyncRequest( async_messages::DEREGISTERED_MODULE,      : AsyncRequest(
             async_messages::DEREGISTERED_MODULE,
                    0,                    0,
                    operation,                    operation,
                    CIMOM_Q_ID,                    CIMOM_Q_ID,
                    service_queue,            serviceQueue,
                    blocking),                    blocking),
      _module(removed_module)        _module(removedModule)
 { {
   
 } }
  
  
 FindModuleInService::FindModuleInService( FindModuleInService::FindModuleInService(
                                          AsyncOpNode *operation,                                          AsyncOpNode *operation,
                                          Boolean blocking,                                          Boolean blocking,
                                          Uint32 response_queue,      Uint32 responseQueue,
                                          String module)      const String& module)
    : AsyncRequest(async_messages::FIND_MODULE_IN_SERVICE,      : AsyncRequest(
             async_messages::FIND_MODULE_IN_SERVICE,
                   0,                   0,
                   operation,                   operation,
                   CIMOM_Q_ID,                   CIMOM_Q_ID,
                   response_queue,            responseQueue,
                   blocking),                   blocking),
      _module(module)      _module(module)
 { {
   
 } }
  
 FindModuleInServiceResponse::FindModuleInServiceResponse( FindModuleInServiceResponse::FindModuleInServiceResponse(
                                                          AsyncOpNode *operation,                                                          AsyncOpNode *operation,
                                                          Uint32 result_code,      Uint32 resultCode,
                                                          Uint32 destination,                                                          Uint32 destination,
                                                          Uint32 blocking,      Boolean blocking,
                                                          Uint32 module_service_queue)      Uint32 moduleServiceQueue)
       : AsyncReply(
    : AsyncReply(async_messages::FIND_MODULE_IN_SERVICE_RESPONSE,            async_messages::FIND_MODULE_IN_SERVICE_RESPONSE,
                 0,                 0,
                 operation,                 operation,
                 result_code,            resultCode,
                 destination,                 destination,
                 blocking),                 blocking),
      _module_service_queue(module_service_queue)        _module_service_queue(moduleServiceQueue)
 { {
   
 } }
  
 AsyncIoctl::AsyncIoctl( AsyncIoctl::AsyncIoctl(
Line 263 
Line 254 
                        Uint32 response,                        Uint32 response,
                        Boolean blocking,                        Boolean blocking,
                        Uint32 code,                        Uint32 code,
                        Uint32 int_param,      Uint32 intParam,
                        void *p_param)      void* pParam)
    : AsyncRequest( async_messages::IOCTL,      : AsyncRequest(
             async_messages::IOCTL,
                    0, operation,                    0, operation,
                    destination, response, blocking),                    destination, response, blocking),
      ctl(code),      ctl(code),
      intp(int_param),        intp(intParam),
      voidp(p_param)        voidp(pParam)
 { {
   
 } }
  
  
Line 281 
Line 272 
                                  Uint32 destination,                                  Uint32 destination,
                                  Uint32 response,                                  Uint32 response,
                                  Boolean blocking)                                  Boolean blocking)
    : AsyncRequest(async_messages::CIMSERVICE_START,      : AsyncRequest(
             async_messages::CIMSERVICE_START,
                   0, operation, destination,                   0, operation, destination,
                   response, blocking)                   response, blocking)
 { {
   
 } }
  
  
Line 294 
Line 285 
                                Uint32 destination,                                Uint32 destination,
                                Uint32 response,                                Uint32 response,
                                Boolean blocking)                                Boolean blocking)
    : AsyncRequest(async_messages::CIMSERVICE_STOP,      : AsyncRequest(
             async_messages::CIMSERVICE_STOP,
                   0, operation, destination,                   0, operation, destination,
                   response, blocking)                   response, blocking)
 { {
   
 } }
  
  
   
 CimServicePause::CimServicePause( CimServicePause::CimServicePause(
                                  AsyncOpNode *operation,                                  AsyncOpNode *operation,
                                  Uint32 destination,                                  Uint32 destination,
                                  Uint32 response,                                  Uint32 response,
                                  Boolean blocking)                                  Boolean blocking)
    : AsyncRequest(async_messages::CIMSERVICE_PAUSE,      : AsyncRequest(
             async_messages::CIMSERVICE_PAUSE,
                   0, operation, destination,                   0, operation, destination,
                   response, blocking)                   response, blocking)
 { {
   
 } }
  
  
Line 321 
Line 311 
                                    Uint32 destination,                                    Uint32 destination,
                                    Uint32 response,                                    Uint32 response,
                                    Boolean blocking)                                    Boolean blocking)
    : AsyncRequest(async_messages::CIMSERVICE_RESUME,      : AsyncRequest(
             async_messages::CIMSERVICE_RESUME,
                   0, operation, destination,                   0, operation, destination,
                   response, blocking)                   response, blocking)
 { {
   
 } }
  
 AsyncOperationStart::AsyncOperationStart( AsyncOperationStart::AsyncOperationStart(
Line 334 
Line 324 
                                          Uint32 response,                                          Uint32 response,
                                          Boolean blocking,                                          Boolean blocking,
                                          Message *action)                                          Message *action)
    : AsyncRequest(async_messages::ASYNC_OP_START,      : AsyncRequest(
             async_messages::ASYNC_OP_START,
                   0,                   0,
                   operation,                   operation,
                   destination, response, blocking),                   destination, response, blocking),
      _act(action)      _act(action)
 { {
   
 } }
  
   Message* AsyncOperationStart::get_action()
 Message * AsyncOperationStart::get_action(void)  
 { {
    Message *ret = _act;    Message *ret = _act;
    _act = 0;    _act = 0;
    ret->put_async(0);    ret->put_async(0);
    return ret;    return ret;
   
 } }
  
   
 AsyncOperationResult::AsyncOperationResult( AsyncOperationResult::AsyncOperationResult(
                                            AsyncOpNode *operation,                                            AsyncOpNode *operation,
                                            Uint32 result_code,      Uint32 resultCode,
                                            Uint32 destination,                                            Uint32 destination,
                                            Uint32 blocking)      Boolean blocking)
    : AsyncReply(async_messages::ASYNC_OP_RESULT,      : AsyncReply(
             async_messages::ASYNC_OP_RESULT,
                 0,                 0,
                 operation, result_code, destination,            operation,
             resultCode,
             destination,
                 blocking)                 blocking)
 { {
   
 } }
  
  
Line 373 
Line 362 
                                                      Uint32 destination,                                                      Uint32 destination,
                                                      Uint32 response,                                                      Uint32 response,
                                                      Boolean blocking,                                                      Boolean blocking,
                                                      String target_module,      const String& targetModule,
                                                      Message *action)                                                      Message *action)
    : AsyncRequest(async_messages::ASYNC_MODULE_OP_START,      : AsyncRequest(
             async_messages::ASYNC_MODULE_OP_START,
                   0,                   0,
                   operation,                   operation,
                   destination, response, blocking),            destination,
      _target_module(target_module),            response,
             blocking),
         _target_module(targetModule),
      _act(action)      _act(action)
 { {
    _act->put_async(this);    _act->put_async(this);
   
 } }
  
  
 Message * AsyncModuleOperationStart::get_action(void)  Message* AsyncModuleOperationStart::get_action()
 { {
    Message *ret = _act;    Message *ret = _act;
    _act = 0;    _act = 0;
    ret->put_async(0);    ret->put_async(0);
    return ret;    return ret;
   
 } }
  
 AsyncModuleOperationResult::AsyncModuleOperationResult( AsyncModuleOperationResult::AsyncModuleOperationResult(
                                                        AsyncOpNode *operation,                                                        AsyncOpNode *operation,
                                                        Uint32 result_code,      Uint32 resultCode,
                                                        Uint32 destination,                                                        Uint32 destination,
                                                        Uint32 blocking,      Boolean blocking,
                                                        String target_module,      const String& targetModule,
                                                        Message *result)                                                        Message *result)
    : AsyncReply(async_messages::ASYNC_MODULE_OP_RESULT,      : AsyncReply(
             async_messages::ASYNC_MODULE_OP_RESULT,
                 0,                 0,
                 operation, result_code, destination,            operation, resultCode, destination,
                 blocking),                 blocking),
      _target_module(target_module),        _targetModule(targetModule),
      _res(result)      _res(result)
 { {
    _res->put_async(this);    _res->put_async(this);
 } }
  
 Message * AsyncModuleOperationResult::get_result(void)  Message* AsyncModuleOperationResult::get_result()
 { {
    Message *ret = _res;    Message *ret = _res;
    _res = 0;    _res = 0;
Line 426 
Line 417 
                                                      AsyncOpNode *operation,                                                      AsyncOpNode *operation,
                                                      Uint32 destination,                                                      Uint32 destination,
                                                      Message *action,                                                      Message *action,
                                                      Uint32 action_destination)      Uint32 actionDestination)
    : AsyncRequest(async_messages::ASYNC_LEGACY_OP_START,      : AsyncRequest(
             async_messages::ASYNC_LEGACY_OP_START,
                   0,                   0,
                   operation, destination, CIMOM_Q_ID, false),                   operation, destination, CIMOM_Q_ID, false),
      _act(action) , _legacy_destination(action_destination)        _act(action),
         _legacy_destination(actionDestination)
 { {
    _act->put_async(this);    _act->put_async(this);
 } }
  
  
 Message * AsyncLegacyOperationStart::get_action(void)  Message* AsyncLegacyOperationStart::get_action()
 { {
    Message *ret = _act;    Message *ret = _act;
    _act = 0;    _act = 0;
Line 448 
Line 441 
 AsyncLegacyOperationResult::AsyncLegacyOperationResult( AsyncLegacyOperationResult::AsyncLegacyOperationResult(
                                                        AsyncOpNode *operation,                                                        AsyncOpNode *operation,
                                                        Message *result)                                                        Message *result)
    : AsyncReply(async_messages::ASYNC_LEGACY_OP_RESULT,      : AsyncReply(
             async_messages::ASYNC_LEGACY_OP_RESULT,
                 0, operation,                 0, operation,
                 0, CIMOM_Q_ID, false),                 0, CIMOM_Q_ID, false),
      _res(result)      _res(result)
Line 456 
Line 450 
    _res->put_async(this);    _res->put_async(this);
 } }
  
 Message *AsyncLegacyOperationResult::get_result(void)  Message* AsyncLegacyOperationResult::get_result()
 { {
    Message *ret = _res;    Message *ret = _res;
    _res = 0;    _res = 0;
Line 468 
Line 462 
                                    AsyncOpNode *operation,                                    AsyncOpNode *operation,
                                    Uint32 response,                                    Uint32 response,
                                    Boolean blocking,                                    Boolean blocking,
                                    String service_name,      const String& serviceName,
                                    Uint32 service_capabilities,      Uint32 serviceCapabilities,
                                    Uint32 service_mask)      Uint32 serviceMask)
    : AsyncRequest(async_messages::FIND_SERVICE_Q,      : AsyncRequest(
             async_messages::FIND_SERVICE_Q,
                   0, operation,                   0, operation,
                   CIMOM_Q_ID,                   CIMOM_Q_ID,
                   response,                   response,
                   blocking),                   blocking),
      name(service_name),        name(serviceName),
      capabilities(service_capabilities),        capabilities(serviceCapabilities),
      mask(service_mask)        mask(serviceMask)
 { {
   
 } }
  
  
 FindServiceQueueResult::FindServiceQueueResult( FindServiceQueueResult::FindServiceQueueResult(
                                                AsyncOpNode *operation,                                                AsyncOpNode *operation,
                                                Uint32 result_code,      Uint32 resultCode,
                                                Uint32 destination,                                                Uint32 destination,
                                                Boolean blocking,                                                Boolean blocking,
                                                Array<Uint32> queue_ids)      Array<Uint32> queueIds)
    : AsyncReply(async_messages::FIND_SERVICE_Q_RESULT,      : AsyncReply(
             async_messages::FIND_SERVICE_Q_RESULT,
                 0, operation,                 0, operation,
                 result_code, destination, blocking),            resultCode, destination, blocking),
      qids(queue_ids)        qids(queueIds)
 { {
   
 } }
  
 EnumerateService::EnumerateService( EnumerateService::EnumerateService(
                                    AsyncOpNode *operation,                                    AsyncOpNode *operation,
                                    Uint32 response,                                    Uint32 response,
                                    Boolean blocking,                                    Boolean blocking,
                                    Uint32 queue_id)      Uint32 queueId)
    : AsyncRequest(async_messages::ENUMERATE_SERVICE,      : AsyncRequest(
             async_messages::ENUMERATE_SERVICE,
                   0,                   0,
                   operation,                   operation,
                   CIMOM_Q_ID,                   CIMOM_Q_ID,
                   response,                   response,
                   blocking),                   blocking),
      qid(queue_id)        qid(queueId)
 { {
   
 } }
  
 EnumerateServiceResponse::EnumerateServiceResponse( EnumerateServiceResponse::EnumerateServiceResponse(
                                                    AsyncOpNode *operation,                                                    AsyncOpNode *operation,
                                                    Uint32 result_code,      Uint32 resultCode,
                                                    Uint32 response,                                                    Uint32 response,
                                                    Boolean blocking,                                                    Boolean blocking,
                                                    String service_name,      const String& serviceName,
                                                    Uint32 service_capabilities,      Uint32 serviceCapabilities,
                                                    Uint32 service_mask,      Uint32 serviceMask,
                                                    Uint32 service_qid)      Uint32 serviceQid)
    : AsyncReply(async_messages::ENUMERATE_SERVICE_RESULT,      : AsyncReply(
             async_messages::ENUMERATE_SERVICE_RESULT,
                 0,                 0,
                 operation,                 operation,
                 result_code,            resultCode,
                 response,                 response,
                 blocking),                 blocking),
      name(service_name),        name(serviceName),
      capabilities(service_capabilities),        capabilities(serviceCapabilities),
      mask(service_mask),        mask(serviceMask),
      qid(service_qid)        qid(serviceQid)
 { {
   
 } }
  
 AsyncMessage::~AsyncMessage(void)  AsyncMessage::~AsyncMessage()
 { {
 } }
  
 AsyncRequest::~AsyncRequest(void)  AsyncRequest::~AsyncRequest()
 { {
 } }
  

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