(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.5 and 1.16

version 1.5, 2002/02/07 00:28:48 version 1.16, 2002/06/01 00:56:30
Line 1 
Line 1 
 //%///-*-c++-*-/////////////////////////////////////////////////////////////////  //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
 // The Open Group, Tivoli Systems // The Open Group, Tivoli Systems
 // //
 // 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
Line 31 
Line 31 
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 const Uint32 CIMOM_Q_ID = MessageQueue::getNextQueueId();  
  
 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;
Line 63 
Line 63 
  
  
  
 const Uint32 async_messages::HEARTBEAT =                0x00000000;  const Uint32 async_messages::HEARTBEAT =                       DUMMY_MESSAGE;
 const Uint32 async_messages::REPLY =                    0x00000000;  const Uint32 async_messages::REPLY =                           DUMMY_MESSAGE;
 const Uint32 async_messages::REGISTER_CIM_SERVICE =     0x00000001;  const Uint32 async_messages::REGISTER_CIM_SERVICE =            NUMBER_OF_MESSAGES + 0x00000001;
 const Uint32 async_messages::DEREGISTER_CIM_SERVICE =   0x00000002;  const Uint32 async_messages::DEREGISTER_CIM_SERVICE =          NUMBER_OF_MESSAGES + 0x00000002;
 const Uint32 async_messages::UPDATE_CIM_SERVICE =       0x00000003;  const Uint32 async_messages::UPDATE_CIM_SERVICE =              NUMBER_OF_MESSAGES + 0x00000003;
 const Uint32 async_messages::IOCTL =                    0x00000004;  const Uint32 async_messages::IOCTL =                           NUMBER_OF_MESSAGES + 0x00000004;
 const Uint32 async_messages::CIMSERVICE_START =         0x00000005;  const Uint32 async_messages::CIMSERVICE_START =                NUMBER_OF_MESSAGES + 0x00000005;
 const Uint32 async_messages::CIMSERVICE_STOP =          0x00000006;  const Uint32 async_messages::CIMSERVICE_STOP =                 NUMBER_OF_MESSAGES + 0x00000006;
 const Uint32 async_messages::CIMSERVICE_PAUSE =         0x00000007;  const Uint32 async_messages::CIMSERVICE_PAUSE =                NUMBER_OF_MESSAGES + 0x00000007;
 const Uint32 async_messages::CIMSERVICE_RESUME =        0x00000008;  const Uint32 async_messages::CIMSERVICE_RESUME =               NUMBER_OF_MESSAGES + 0x00000008;
   
 const Uint32 async_messages::ASYNC_OP_START =           0x00000009;  const Uint32 async_messages::ASYNC_OP_START =                  NUMBER_OF_MESSAGES + 0x00000009;
 const Uint32 async_messages::ASYNC_OP_RESULT =          0x0000000a;  const Uint32 async_messages::ASYNC_OP_RESULT =                 NUMBER_OF_MESSAGES + 0x0000000a;
 const Uint32 async_messages::ASYNC_LEGACY_OP_START =    0x0000000b;  const Uint32 async_messages::ASYNC_LEGACY_OP_START =           NUMBER_OF_MESSAGES + 0x0000000b;
 const Uint32 async_messages::ASYNC_LEGACY_OP_RESULT =   0x0000000c;  const Uint32 async_messages::ASYNC_LEGACY_OP_RESULT =          NUMBER_OF_MESSAGES + 0x0000000c;
   
 const Uint32 async_messages::FIND_SERVICE_Q =           0x0000000d;  const Uint32 async_messages::FIND_SERVICE_Q =                  NUMBER_OF_MESSAGES + 0x0000000d;
 const Uint32 async_messages::FIND_SERVICE_Q_RESULT =    0x0000000e;  const Uint32 async_messages::FIND_SERVICE_Q_RESULT =           NUMBER_OF_MESSAGES + 0x0000000e;
 const Uint32 async_messages::ENUMERATE_SERVICE =        0x0000000f;  const Uint32 async_messages::ENUMERATE_SERVICE =               NUMBER_OF_MESSAGES + 0x0000000f;
 const Uint32 async_messages::ENUMERATE_SERVICE_RESULT = 0x00000010;  const Uint32 async_messages::ENUMERATE_SERVICE_RESULT =        NUMBER_OF_MESSAGES + 0x00000010;
   
   const Uint32 async_messages::REGISTERED_MODULE =               NUMBER_OF_MESSAGES + 0x00000011;
   const Uint32 async_messages::DEREGISTERED_MODULE =             NUMBER_OF_MESSAGES + 0x00000012;
   const Uint32 async_messages::FIND_MODULE_IN_SERVICE =          NUMBER_OF_MESSAGES + 0x00000013;
   const Uint32 async_messages::FIND_MODULE_IN_SERVICE_RESPONSE = NUMBER_OF_MESSAGES + 0x00000014;
   
   const Uint32 async_messages::ASYNC_MODULE_OP_START =           NUMBER_OF_MESSAGES + 0x00000015;
   const Uint32 async_messages::ASYNC_MODULE_OP_RESULT  =         NUMBER_OF_MESSAGES + 0x00000016;
   
  
  
 AsyncMessage::AsyncMessage(Uint32 type, AsyncMessage::AsyncMessage(Uint32 type,
                              Uint32 destination,
                            Uint32 key,                            Uint32 key,
                            Uint32 routing,                            Uint32 routing,
                            Uint32 mask,                            Uint32 mask,
                            AsyncOpNode *operation)                            AsyncOpNode *operation)
    : Message(type, key, routing, mask | message_mask::ha_async),     : Message(type, destination, key, routing, mask | message_mask::ha_async),
      op(operation),       op(operation)
      _myself(0),  
      _service(0)  
 { {
  
 } }
  
   
 AsyncRequest::AsyncRequest(Uint32 type, AsyncRequest::AsyncRequest(Uint32 type,
                            Uint32 key,                            Uint32 key,
                            Uint32 routing,                            Uint32 routing,
Line 107 
Line 114 
                            Uint32 destination,                            Uint32 destination,
                            Uint32 response,                            Uint32 response,
                            Boolean blocking)                            Boolean blocking)
    : AsyncMessage(type, key, routing, mask | message_mask::ha_request, operation),     : AsyncMessage(type, destination, key, routing, mask | message_mask::ha_request, operation),
      dest(destination),  
      resp(response),      resp(response),
      block(blocking)      block(blocking)
 { {
Line 124 
Line 130 
                        Uint32 result_code,                        Uint32 result_code,
                        Uint32 destination,                        Uint32 destination,
                        Boolean blocking)                        Boolean blocking)
    : AsyncMessage(type, key, routing, mask | message_mask::ha_reply, operation),     : AsyncMessage(type, destination, key, routing, mask | message_mask::ha_reply, operation),
      result(result_code),      result(result_code),
      dest(destination),  
      block(blocking)      block(blocking)
 { {
    if( op != 0 )    if( op != 0 )
Line 188 
Line 193 
  
 } }
  
   RegisteredModule::RegisteredModule(Uint32 routing,
                                      AsyncOpNode *operation,
                                      Boolean blocking,
                                      Uint32 service_queue,
                                      String new_module)
      : AsyncRequest( async_messages::REGISTERED_MODULE,
                      Message::getNextKey(),
                      routing,
                      0,
                      operation,
                      CIMOM_Q_ID,
                      service_queue,
                      blocking),
        _module(new_module)
   {
   
   }
   
   DeRegisteredModule::DeRegisteredModule(Uint32 routing,
                                        AsyncOpNode *operation,
                                        Boolean blocking,
                                        Uint32 service_queue,
                                        String removed_module)
      : AsyncRequest( async_messages::DEREGISTERED_MODULE,
                      Message::getNextKey(),
                      routing,
                      0,
                      operation,
                      CIMOM_Q_ID,
                      service_queue,
                      blocking),
        _module(removed_module)
   {
   
   }
   
   
   FindModuleInService::FindModuleInService(Uint32 routing,
                                            AsyncOpNode *operation,
                                            Boolean blocking,
                                            Uint32 response_queue,
                                            String module)
      : AsyncRequest(async_messages::FIND_MODULE_IN_SERVICE,
                     Message::getNextKey(),
                     routing,
                     0,
                     operation,
                     CIMOM_Q_ID,
                     response_queue,
                     blocking),
        _module(module)
   {
   
   }
   
   FindModuleInServiceResponse::FindModuleInServiceResponse(Uint32 routing,
                                                            Uint32 key,
                                                            AsyncOpNode *operation,
                                                            Uint32 result_code,
                                                            Uint32 destination,
                                                            Uint32 blocking,
                                                            Uint32 module_service_queue)
   
      : AsyncReply(async_messages::FIND_MODULE_IN_SERVICE_RESPONSE,
                   key,
                   routing,
                   0,
                   operation,
                   result_code,
                   destination,
                   blocking),
        _module_service_queue(module_service_queue)
   {
   
   }
  
 AsyncIoctl::AsyncIoctl(Uint32 routing, AsyncIoctl::AsyncIoctl(Uint32 routing,
                        AsyncOpNode *operation,                        AsyncOpNode *operation,
Line 275 
Line 355 
                   Message::getNextKey(), routing, 0,                   Message::getNextKey(), routing, 0,
                   operation,                   operation,
                   destination, response, blocking),                   destination, response, blocking),
      act(action)       _act(action)
 { {
    if( op != 0 )  
       op->put_request(act);  }
   
   
   Message * AsyncOperationStart::get_action(void)
   {
      Message *ret = _act;
      _act = 0;
      ret->put_async(0);
      return ret;
   
 } }
  
  
Line 297 
Line 386 
 } }
  
  
   AsyncModuleOperationStart::AsyncModuleOperationStart(Uint32 routing,
                                                        AsyncOpNode *operation,
                                                        Uint32 destination,
                                                        Uint32 response,
                                                        Boolean blocking,
                                                        String target_module,
                                                        Message *action)
      : AsyncRequest(async_messages::ASYNC_MODULE_OP_START,
                     Message::getNextKey(), routing, 0,
                     operation,
                     destination, response, blocking),
        _target_module(target_module),
        _act(action)
   {
      _act->put_async(this);
   
   }
   
   
   Message * AsyncModuleOperationStart::get_action(void)
   {
      Message *ret = _act;
      _act = 0;
      ret->put_async(0);
      return ret;
   
   }
   
   AsyncModuleOperationResult::AsyncModuleOperationResult(Uint32 key,
                                                          Uint32 routing,
                                                          AsyncOpNode *operation,
                                                          Uint32 result_code,
                                                          Uint32 destination,
                                                          Uint32 blocking,
                                                          String target_module,
                                                          Message *result)
      : AsyncReply(async_messages::ASYNC_MODULE_OP_RESULT,
                   key, routing, 0,
                   operation, result_code, destination,
                   blocking),
        _target_module(target_module),
        _res(result)
   {
      _res->put_async(this);
   }
   
   Message * AsyncModuleOperationResult::get_result(void)
   {
      Message *ret = _res;
      _res = 0;
      ret->put_async(0);
      return ret;
   }
   
  
 AsyncLegacyOperationStart::AsyncLegacyOperationStart(Uint32 routing, AsyncLegacyOperationStart::AsyncLegacyOperationStart(Uint32 routing,
                                                      AsyncOpNode *operation,                                                      AsyncOpNode *operation,
Line 306 
Line 449 
    : AsyncRequest(async_messages::ASYNC_LEGACY_OP_START,    : AsyncRequest(async_messages::ASYNC_LEGACY_OP_START,
                   Message::getNextKey(), routing, 0,                   Message::getNextKey(), routing, 0,
                   operation, destination, CIMOM_Q_ID, false),                   operation, destination, CIMOM_Q_ID, false),
      act(action) , legacy_destination(action_destination)       _act(action) , _legacy_destination(action_destination)
 { {
      _act->put_async(this);
 } }
  
  
   Message * AsyncLegacyOperationStart::get_action(void)
   {
      Message *ret = _act;
      _act = 0;
   //   ret->put_async(0);
      return ret;
   
   }
   
 AsyncLegacyOperationResult::AsyncLegacyOperationResult(Uint32 key, AsyncLegacyOperationResult::AsyncLegacyOperationResult(Uint32 key,
                                                        Uint32 routing,                                                        Uint32 routing,
                                                        AsyncOpNode *operation,                                                        AsyncOpNode *operation,
Line 319 
Line 471 
    : AsyncReply(async_messages::ASYNC_LEGACY_OP_RESULT,    : AsyncReply(async_messages::ASYNC_LEGACY_OP_RESULT,
                 key, routing, 0, operation,                 key, routing, 0, operation,
                 0, CIMOM_Q_ID, false),                 0, CIMOM_Q_ID, false),
      res(result)       _res(result)
 { {
      _res->put_async(this);
 } }
  
   Message *AsyncLegacyOperationResult::get_result(void)
   {
      Message *ret = _res;
      _res = 0;
   //   ret->put_async(0);
      return ret;
   }
  
 FindServiceQueue::FindServiceQueue(Uint32 routing, FindServiceQueue::FindServiceQueue(Uint32 routing,
                                    AsyncOpNode *operation,                                    AsyncOpNode *operation,
Line 347 
Line 505 
 } }
  
  
   
 FindServiceQueueResult::FindServiceQueueResult(Uint32 key, FindServiceQueueResult::FindServiceQueueResult(Uint32 key,
                                                Uint32 routing,                                                Uint32 routing,
                                                AsyncOpNode *operation,                                                AsyncOpNode *operation,

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