(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.13 and 1.37

version 1.13, 2002/03/19 21:03:37 version 1.37, 2009/04/17 13:21:30
Line 1 
Line 1 
 //%///-*-c++-*-/////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 BMC Software, Hewlett-Packard Company, IBM,  // Licensed to The Open Group (TOG) under one or more contributor license
 // The Open Group, Tivoli Systems  // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
   // this work for additional information regarding copyright ownership.
   // Each contributor licenses this file to you under the OpenPegasus Open
   // Source License; you may not use this file except in compliance with the
   // License.
   //
   // Permission is hereby granted, free of charge, to any person obtaining a
   // copy of this software and associated documentation files (the "Software"),
   // to deal in the Software without restriction, including without limitation
   // the rights to use, copy, modify, merge, publish, distribute, sublicense,
   // and/or sell copies of the Software, and to permit persons to whom the
   // Software is furnished to do so, subject to the following conditions:
   //
   // The above copyright notice and this permission notice shall be included
   // in all copies or substantial portions of 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.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy  //////////////////////////////////////////////////////////////////////////
 // of this software and associated documentation files (the "Software"), to  
 // deal in the Software without restriction, including without limitation the  
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  
 // sell copies of the Software, and to permit persons to whom the Software is  
 // furnished to do so, subject to the following conditions:  
 //  
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF 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.  
 //  
 //==============================================================================  
 //  
 // Author: Mike Day (mdday@us.ibm.com)  
 //  
 // Modified By:  
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 31 
Line 33 
  
 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;  
   
   
   
 const Uint32 async_messages::HEARTBEAT =                       0x00000000;  
 const Uint32 async_messages::REPLY =                           0x00000000;  
 const Uint32 async_messages::REGISTER_CIM_SERVICE =            0x00000001;  
 const Uint32 async_messages::DEREGISTER_CIM_SERVICE =          0x00000002;  
 const Uint32 async_messages::UPDATE_CIM_SERVICE =              0x00000003;  
 const Uint32 async_messages::IOCTL =                           0x00000004;  
 const Uint32 async_messages::CIMSERVICE_START =                0x00000005;  
 const Uint32 async_messages::CIMSERVICE_STOP =                 0x00000006;  
 const Uint32 async_messages::CIMSERVICE_PAUSE =                0x00000007;  
 const Uint32 async_messages::CIMSERVICE_RESUME =               0x00000008;  
   
 const Uint32 async_messages::ASYNC_OP_START =                  0x00000009;  
 const Uint32 async_messages::ASYNC_OP_RESULT =                 0x0000000a;  
 const Uint32 async_messages::ASYNC_LEGACY_OP_START =           0x0000000b;  
 const Uint32 async_messages::ASYNC_LEGACY_OP_RESULT =          0x0000000c;  
   
 const Uint32 async_messages::FIND_SERVICE_Q =                  0x0000000d;  
 const Uint32 async_messages::FIND_SERVICE_Q_RESULT =           0x0000000e;  
 const Uint32 async_messages::ENUMERATE_SERVICE =               0x0000000f;  
 const Uint32 async_messages::ENUMERATE_SERVICE_RESULT =        0x00000010;  
   
 const Uint32 async_messages::REGISTERED_MODULE =               0x00000011;  
 const Uint32 async_messages::DEREGISTERED_MODULE =             0x00000012;  
 const Uint32 async_messages::FIND_MODULE_IN_SERVICE =          0x00000013;  
 const Uint32 async_messages::FIND_MODULE_IN_SERVICE_RESPONSE = 0x00000014;  
  
 const Uint32 async_messages::ASYNC_MODULE_OP_START =           0x00000015;  
 const Uint32 async_messages::ASYNC_MODULE_OP_RESULT  =         0x00000016;  
  
   AsyncMessage::AsyncMessage(
       MessageType type,
 AsyncMessage::AsyncMessage(Uint32 type,  
                            Uint32 destination,                            Uint32 destination,
                            Uint32 key,  
                            Uint32 routing,  
                            Uint32 mask,                            Uint32 mask,
                            AsyncOpNode *operation)                            AsyncOpNode *operation)
    : Message(type, destination, key, routing, mask | message_mask::ha_async),      : Message(type, destination, mask | MessageMask::ha_async),
      op(operation)      op(operation)
 { {
   
 } }
  
 AsyncRequest::AsyncRequest(Uint32 type,  AsyncRequest::AsyncRequest(
                            Uint32 key,      MessageType type,
                            Uint32 routing,  
                            Uint32 mask,                            Uint32 mask,
                            AsyncOpNode *operation,                            AsyncOpNode *operation,
                            Uint32 destination,      Uint32 destination)
                            Uint32 response,      : AsyncMessage(
                            Boolean blocking)            type, destination, mask | MessageMask::ha_request, operation)
    : AsyncMessage(type, destination, key, routing, mask | message_mask::ha_request, operation),  
      resp(response),  
      block(blocking)  
 { {
    if( op != 0 )    if( op != 0 )
       op->put_request(this);          op->setRequest(this);
 } }
  
 AsyncReply::AsyncReply(Uint32 type,  AsyncReply::AsyncReply(
                        Uint32 key,      MessageType type,
                        Uint32 routing,  
                        Uint32 mask,                        Uint32 mask,
                        AsyncOpNode *operation,                        AsyncOpNode *operation,
                        Uint32 result_code,      Uint32 resultCode)
                        Uint32 destination,      : AsyncMessage(
                        Boolean blocking)            type,0, mask | MessageMask::ha_reply, operation),
    : AsyncMessage(type, destination, key, routing, mask | message_mask::ha_reply, operation),        result(resultCode)
      result(result_code),  
      block(blocking)  
 { {
    if( op != 0 )    if( op != 0 )
       op->put_response(this);          op->setResponse(this);
 } }
  
   AsyncIoClose::AsyncIoClose(
   
   
 RegisterCimService::RegisterCimService(Uint32 routing,  
                                        AsyncOpNode *operation,                                        AsyncOpNode *operation,
                                        Boolean blocking,      Uint32 destination)
                                        String service_name,      : AsyncRequest(
                                        Uint32 service_capabilities,            ASYNC_IOCLOSE,
                                        Uint32 service_mask,  
                                        Uint32 service_queue)  
    : AsyncRequest( async_messages::REGISTER_CIM_SERVICE,  
                    Message::getNextKey(),  
                    routing, 0, operation, CIMOM_Q_ID,  
                    service_queue, blocking),  
      name(service_name),  
      capabilities(service_capabilities),  
      mask(service_mask),  
      queue(service_queue)  
 {  
   
 }  
   
   
 DeRegisterCimService::DeRegisterCimService(Uint32 routing,  
                                            AsyncOpNode *operation,  
                                            Boolean blocking,  
                                            Uint32 service_queue)  
    : AsyncRequest( async_messages::DEREGISTER_CIM_SERVICE,  
                    Message::getNextKey(),  
                    routing, 0, operation, CIMOM_Q_ID,  
                    service_queue, blocking),  
      queue(service_queue)  
 {  
   
 }  
   
   
   
 UpdateCimService::UpdateCimService(Uint32 routing,  
                                    AsyncOpNode *operation,  
                                    Boolean blocking,  
                                    Uint32 service_queue,  
                                    Uint32 service_capabilities,  
                                    Uint32 service_mask)  
    : AsyncRequest( async_messages::UPDATE_CIM_SERVICE,  
                    Message::getNextKey(),  
                    routing, 0, operation, CIMOM_Q_ID,  
                    service_queue, blocking),  
      queue(service_queue),  
      capabilities(service_capabilities),  
      mask(service_mask)  
 {  
   
 }  
   
 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,                 0,
                 operation,                 operation,
                 result_code,            destination)
                 destination,  
                 blocking),  
      _module_service_queue(module_service_queue)  
 { {
   
 } }
  
 AsyncIoctl::AsyncIoctl(Uint32 routing,  CimServiceStart::CimServiceStart(
                        AsyncOpNode *operation,                        AsyncOpNode *operation,
                        Uint32 destination,      Uint32 destination)
                        Uint32 response,      : AsyncRequest(
                        Boolean blocking,            ASYNC_CIMSERVICE_START,
                        Uint32 code,            0, operation, destination)
                        Uint32 int_param,  
                        void *p_param)  
    : AsyncRequest( async_messages::IOCTL,  
                    Message::getNextKey(),  
                    routing, 0, operation,  
                    destination, response, blocking),  
      ctl(code),  
      intp(int_param),  
      voidp(p_param)  
 { {
   
 } }
  
  
 CimServiceStart::CimServiceStart(Uint32 routing,  CimServiceStop::CimServiceStop(
                                  AsyncOpNode *operation,                                  AsyncOpNode *operation,
                                  Uint32 destination,      Uint32 destination)
                                  Uint32 response,      : AsyncRequest(
                                  Boolean blocking)            ASYNC_CIMSERVICE_STOP,
    : AsyncRequest(async_messages::CIMSERVICE_START,            0, operation, destination)
                   Message::getNextKey(), routing,  
                   0, operation, destination,  
                   response, blocking)  
 { {
   
 } }
  
   AsyncOperationStart::AsyncOperationStart(
 CimServiceStop::CimServiceStop(Uint32 routing,  
                                AsyncOpNode *operation,                                AsyncOpNode *operation,
                                Uint32 destination,                                Uint32 destination,
                                Uint32 response,  
                                Boolean blocking)  
    : AsyncRequest(async_messages::CIMSERVICE_STOP,  
                   Message::getNextKey(), routing,  
                   0, operation, destination,  
                   response, blocking)  
 {  
   
 }  
   
   
   
 CimServicePause::CimServicePause(Uint32 routing,  
                                  AsyncOpNode *operation,  
                                  Uint32 destination,  
                                  Uint32 response,  
                                  Boolean blocking)  
    : AsyncRequest(async_messages::CIMSERVICE_PAUSE,  
                   Message::getNextKey(), routing,  
                   0, operation, destination,  
                   response, blocking)  
 {  
   
 }  
   
   
 CimServiceResume::CimServiceResume(Uint32 routing,  
                                    AsyncOpNode *operation,  
                                    Uint32 destination,  
                                    Uint32 response,  
                                    Boolean blocking)  
    : AsyncRequest(async_messages::CIMSERVICE_RESUME,  
                   Message::getNextKey(), routing,  
                   0, operation, destination,  
                   response, blocking)  
 {  
   
 }  
   
 AsyncOperationStart::AsyncOperationStart(Uint32 routing,  
                                          AsyncOpNode *operation,  
                                          Uint32 destination,  
                                          Uint32 response,  
                                          Boolean blocking,  
                                          Message *action)                                          Message *action)
    : AsyncRequest(async_messages::ASYNC_OP_START,      : AsyncRequest(
                   Message::getNextKey(), routing, 0,            ASYNC_ASYNC_OP_START,
             0,
                   operation,                   operation,
                   destination, response, blocking),            destination),
      _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(Uint32 key,  
                                            Uint32 routing,  
                                            AsyncOpNode *operation,                                            AsyncOpNode *operation,
                                            Uint32 result_code,      Uint32 resultCode)
                                            Uint32 destination,      : AsyncReply(
                                            Uint32 blocking)            ASYNC_ASYNC_OP_RESULT,
    : AsyncReply(async_messages::ASYNC_OP_RESULT,            0,
                 key, routing, 0,            operation,
                 operation, result_code, destination,            resultCode)
                 blocking)  
 { {
   
 } }
  
  
 AsyncModuleOperationStart::AsyncModuleOperationStart(Uint32 routing,  AsyncModuleOperationStart::AsyncModuleOperationStart(
                                                      AsyncOpNode *operation,                                                      AsyncOpNode *operation,
                                                      Uint32 destination,                                                      Uint32 destination,
                                                      Uint32 response,      const String& targetModule,
                                                      Boolean blocking,  
                                                      String target_module,  
                                                      Message *action)                                                      Message *action)
    : AsyncRequest(async_messages::ASYNC_MODULE_OP_START,      : AsyncRequest(
                   Message::getNextKey(), routing, 0,            ASYNC_ASYNC_MODULE_OP_START,
             0,
                   operation,                   operation,
                   destination, response, blocking),            destination),
      _target_module(target_module),        _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(Uint32 key,  AsyncModuleOperationResult::AsyncModuleOperationResult(
                                                        Uint32 routing,  
                                                        AsyncOpNode *operation,                                                        AsyncOpNode *operation,
                                                        Uint32 result_code,      Uint32 resultCode,
                                                        Uint32 destination,      const String& targetModule,
                                                        Uint32 blocking,  
                                                        String target_module,  
                                                        Message *result)                                                        Message *result)
    : AsyncReply(async_messages::ASYNC_MODULE_OP_RESULT,      : AsyncReply(
                 key, routing, 0,            ASYNC_ASYNC_MODULE_OP_RESULT,
                 operation, result_code, destination,            0,
                 blocking),            operation, resultCode),
      _target_module(target_module),        _targetModule(targetModule),
      _res(result)      _res(result)
 { {
    _res->put_async(this);    _res->put_async(this);
 } }
  
 AsyncLegacyOperationStart::AsyncLegacyOperationStart(Uint32 routing,  Message* AsyncModuleOperationResult::get_result()
   {
       Message* ret = _res;
       _res = 0;
       ret->put_async(0);
       return ret;
   }
   
   
   AsyncLegacyOperationStart::AsyncLegacyOperationStart(
                                                      AsyncOpNode *operation,                                                      AsyncOpNode *operation,
                                                      Uint32 destination,                                                      Uint32 destination,
                                                      Message *action,      Message* action)
                                                      Uint32 action_destination)      : AsyncRequest(
    : AsyncRequest(async_messages::ASYNC_LEGACY_OP_START,            ASYNC_ASYNC_LEGACY_OP_START,
                   Message::getNextKey(), routing, 0,            0,
                   operation, destination, CIMOM_Q_ID, false),            operation, destination),
      _act(action) , _legacy_destination(action_destination)        _act(action)
 { {
    _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 455 
Line 208 
  
 } }
  
 AsyncLegacyOperationResult::AsyncLegacyOperationResult(Uint32 key,  AsyncLegacyOperationResult::AsyncLegacyOperationResult(
                                                        Uint32 routing,  
                                                        AsyncOpNode *operation,                                                        AsyncOpNode *operation,
                                                        Message *result)                                                        Message *result)
    : AsyncReply(async_messages::ASYNC_LEGACY_OP_RESULT,      : AsyncReply(
                 key, routing, 0, operation,            ASYNC_ASYNC_LEGACY_OP_RESULT,
                 0, CIMOM_Q_ID, false),            0, operation, 0),
      _res(result)      _res(result)
 { {
    _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 475 
Line 227 
    return ret;    return ret;
 } }
  
 FindServiceQueue::FindServiceQueue(Uint32 routing,  AsyncMessage::~AsyncMessage()
                                    AsyncOpNode *operation,  
                                    Uint32 response,  
                                    Boolean blocking,  
                                    String service_name,  
                                    Uint32 service_capabilities,  
                                    Uint32 service_mask)  
    : AsyncRequest(async_messages::FIND_SERVICE_Q,  
                   Message::getNextKey(),  
                   routing, 0, operation,  
                   CIMOM_Q_ID,  
                   response,  
                   blocking),  
      name(service_name),  
      capabilities(service_capabilities),  
      mask(service_mask)  
 {  
   
 }  
   
   
 FindServiceQueueResult::FindServiceQueueResult(Uint32 key,  
                                                Uint32 routing,  
                                                AsyncOpNode *operation,  
                                                Uint32 result_code,  
                                                Uint32 destination,  
                                                Boolean blocking,  
                                                Array<Uint32> queue_ids)  
    : AsyncReply(async_messages::FIND_SERVICE_Q_RESULT,  
                 key, routing, 0, operation,  
                 result_code, destination, blocking),  
      qids(queue_ids)  
 {  
   
 }  
   
 EnumerateService::EnumerateService(Uint32 routing,  
                                    AsyncOpNode *operation,  
                                    Uint32 response,  
                                    Boolean blocking,  
                                    Uint32 queue_id)  
    : AsyncRequest(async_messages::ENUMERATE_SERVICE,  
                   Message::getNextKey(),  
                   routing, 0,  
                   operation,  
                   CIMOM_Q_ID,  
                   response,  
                   blocking),  
      qid(queue_id)  
 { {
   
 } }
  
 EnumerateServiceResponse::EnumerateServiceResponse(Uint32 key,  AsyncRequest::~AsyncRequest()
                                                    Uint32 routing,  
                                                    AsyncOpNode *operation,  
                                                    Uint32 result_code,  
                                                    Uint32 response,  
                                                    Boolean blocking,  
                                                    String service_name,  
                                                    Uint32 service_capabilities,  
                                                    Uint32 service_mask,  
                                                    Uint32 service_qid)  
    : AsyncReply(async_messages::ENUMERATE_SERVICE_RESULT,  
                 key,  
                 routing, 0,  
                 operation,  
                 result_code,  
                 response,  
                 blocking),  
      name(service_name),  
      capabilities(service_capabilities),  
      mask(service_mask),  
      qid(service_qid)  
 { {
   
 } }
  
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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