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

Diff for /pegasus/src/Pegasus/Common/ModuleController.h between version 1.19 and 1.24

version 1.19, 2002/04/05 20:10:09 version 1.24, 2002/05/11 03:05:54
Line 109 
Line 109 
             void (*_shutdown_notify)(Uint32 code, void *);             void (*_shutdown_notify)(Uint32 code, void *);
  
             static Message * default_receive_message(Message *msg, void *inst)             static Message * default_receive_message(Message *msg, void *inst)
             { throw NotImplemented("Module Receive");}              { throw NotImplemented("Module Receive"); return 0; }
  
             static void default_async_callback(Uint32 handle, Message *msg, void *inst)             static void default_async_callback(Uint32 handle, Message *msg, void *inst)
             { throw NotImplemented("Module Async Receive"); }             { throw NotImplemented("Module Async Receive"); }
Line 118 
Line 118 
             { return; }             { return; }
  
             static Message * closed_receive_message(Message *msg, void *inst)             static Message * closed_receive_message(Message *msg, void *inst)
             { throw ModuleClosed();}              { throw ModuleClosed(); return 0; }
  
             static void closed_async_callback(Uint32 handle, Message *msg, void *inst)             static void closed_async_callback(Uint32 handle, Message *msg, void *inst)
             { throw ModuleClosed(); }             { throw ModuleClosed(); }
Line 165 
Line 165 
       void _send_async_callback(Uint32 msg_handle, Message *msg, void *) ;       void _send_async_callback(Uint32 msg_handle, Message *msg, void *) ;
       void _send_shutdown_notify(void);       void _send_shutdown_notify(void);
       Boolean _shutdown(void);       Boolean _shutdown(void);
       bitset<32> _allowed_operations;        PEGASUS_STD(bitset<32>) _allowed_operations;
  
       void reference(void) { _rep->reference(); }       void reference(void) { _rep->reference(); }
       void dereference(void)  { _rep->dereference(); }       void dereference(void)  { _rep->dereference(); }
Line 198 
Line 198 
       static const Uint32 CLIENT_SEND_ASYNC_MODULE;       static const Uint32 CLIENT_SEND_ASYNC_MODULE;
       static const Uint32 CLIENT_BLOCKING_THREAD_EXEC;       static const Uint32 CLIENT_BLOCKING_THREAD_EXEC;
       static const Uint32 CLIENT_ASYNC_THREAD_EXEC;       static const Uint32 CLIENT_ASYNC_THREAD_EXEC;
         static const Uint32 CLIENT_SEND_FORGET;
         static const Uint32 CLIENT_SEND_FORGET_MODULE;
         static const Uint32 MODULE_SEND_FORGET;
         static const Uint32 MODULE_SEND_FORGET_MODULE;
  
   // ATTN-DME-P2-20020406 Removed private declaration.  client_handle is
   //          currently used in Pegasus/Provider/CIMOMHandle.cpp
  
    private:  //   private:
       class client_handle : public pegasus_auth_handle       class client_handle : public pegasus_auth_handle
       {       {
          public:          public:
Line 219 
Line 225 
                                     CLIENT_BLOCKING_THREAD_EXEC |                                     CLIENT_BLOCKING_THREAD_EXEC |
                                     CLIENT_ASYNC_THREAD_EXEC)                                     CLIENT_ASYNC_THREAD_EXEC)
             {             {
   
             }             }
  
             ~client_handle(void)             ~client_handle(void)
Line 229 
Line 234 
             virtual Boolean authorized(Uint32, Uint32);             virtual Boolean authorized(Uint32, Uint32);
             virtual Boolean authorized(Uint32 operation);             virtual Boolean authorized(Uint32 operation);
             virtual Boolean authorized(void);             virtual Boolean authorized(void);
             bitset<32> allowed_operations;              PEGASUS_STD(bitset<32>) allowed_operations;
   
       };       };
  
       class callback_handle       class callback_handle
Line 243 
Line 247 
  
             ~callback_handle()             ~callback_handle()
             {             {
                if( _module->get_name() == String(PEGASUS_CONTROL_TEMP_MODULE) )                 if( _module->get_name() == String(PEGASUS_MODULENAME_TEMP) )
                   delete _module;                   delete _module;
             }             }
  
Line 283 
Line 287 
       Boolean deregister_module(const String & module_name)       Boolean deregister_module(const String & module_name)
          throw(Permission);          throw(Permission);
  
       Uint32 find_service(pegasus_module & handle, const String & name) throw(Permission);        Uint32 find_service(const pegasus_module & handle, const String & name) throw(Permission);
  
       Uint32 find_module_in_service(pegasus_module & handle,        Uint32 find_module_in_service(const pegasus_module & handle,
                                     const String & module_name)                                     const String & module_name)
          throw(Permission, IPCException);          throw(Permission, IPCException);
  
  
       pegasus_module * get_module_reference(pegasus_module & my_handle,        pegasus_module * get_module_reference(const pegasus_module & my_handle,
                                             const String & module_name)                                             const String & module_name)
          throw(Permission);          throw(Permission);
  
       // send a message to another service       // send a message to another service
       AsyncReply *ModuleSendWait(pegasus_module & handle,        AsyncReply *ModuleSendWait(const pegasus_module & handle,
                               Uint32 destination_q,                               Uint32 destination_q,
                               AsyncRequest *request) throw(Permission, IPCException);                               AsyncRequest *request) throw(Permission, IPCException);
  
       // send a message to another module via another service       // send a message to another module via another service
       AsyncReply *ModuleSendWait(pegasus_module & handle,        AsyncReply *ModuleSendWait(const pegasus_module & handle,
                               Uint32 destination_q,                               Uint32 destination_q,
                               String & destination_module,                                   const String & destination_module,
                               AsyncRequest *message) throw(Permission, Deadlock, IPCException);                               AsyncRequest *message) throw(Permission, Deadlock, IPCException);
  
       // send an async message to another service       // send an async message to another service
       Boolean ModuleSendAsync(pegasus_module & handle,        Boolean ModuleSendAsync(const pegasus_module & handle,
                               Uint32 msg_handle,                               Uint32 msg_handle,
                               Uint32 destination_q,                               Uint32 destination_q,
                               AsyncRequest *message,                               AsyncRequest *message,
                               void *callback_parm) throw(Permission, IPCException);                               void *callback_parm) throw(Permission, IPCException);
  
       // send an async message to another module via another service       // send an async message to another module via another service
       Boolean ModuleSendAsync(pegasus_module & handle,        Boolean ModuleSendAsync(const pegasus_module & handle,
                               Uint32 msg_handle,                               Uint32 msg_handle,
                               Uint32 destination_q,                               Uint32 destination_q,
                               String & destination_module,                                const String & destination_module,
                               AsyncRequest *message,                               AsyncRequest *message,
                               void *callback_parm) throw(Permission, IPCException);                               void *callback_parm) throw(Permission, IPCException);
  
       void blocking_thread_exec(pegasus_module & handle,        Boolean ModuleSendForget(const pegasus_module & handle,
                                  Uint32 destination_q,
                                  AsyncRequest *message)
            throw(Permission, IPCException);
   
         Boolean ModuleSendForget(const pegasus_module & handle,
                                  Uint32 destination_q,
                                  const String & destination_module,
                                  AsyncRequest *message)
            throw(Permission, IPCException);
   
         void blocking_thread_exec(const pegasus_module & handle,
                                 PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),                                 PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
                                 void *parm) throw(Permission, Deadlock, IPCException);                                 void *parm) throw(Permission, Deadlock, IPCException);
       void async_thread_exec(pegasus_module & handle,        void async_thread_exec(const pegasus_module & handle,
                              PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),                              PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
                              void *parm) throw(Permission, Deadlock, IPCException);                              void *parm) throw(Permission, Deadlock, IPCException);
  
Line 367 
Line 382 
                               void *callback_parm )                               void *callback_parm )
          throw(Permission, IPCException);          throw(Permission, IPCException);
  
         Boolean ClientSendForget(const client_handle & handle,
                                  Uint32 destination_q,
                                  AsyncRequest *message)
            throw(Permission, IPCException);
   
         Boolean ClientSendForget(const client_handle & handle,
                                  Uint32 destination_q,
                                  String & destination_module,
                                  AsyncRequest *message)
            throw(Permission, IPCException);
   
       void client_blocking_thread_exec(const client_handle & handle,       void client_blocking_thread_exec(const client_handle & handle,
                                        PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),                                        PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
                                        void *parm)                                        void *parm)
Line 392 
Line 418 
       ThreadPool _thread_pool;       ThreadPool _thread_pool;
       pegasus_module _internal_module;       pegasus_module _internal_module;
       AsyncReply *_send_wait(Uint32, AsyncRequest *);       AsyncReply *_send_wait(Uint32, AsyncRequest *);
       AsyncReply *_send_wait(Uint32, String &, AsyncRequest *);        AsyncReply *_send_wait(Uint32, const String &, AsyncRequest *);
         Boolean _send_forget(Uint32, AsyncRequest *) throw(IPCException);
         Boolean _send_forget(Uint32, const String &, AsyncRequest *) throw(IPCException);
   
       void _blocking_thread_exec(       void _blocking_thread_exec(
          PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),          PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
          void *parm) ;          void *parm) ;
       void _async_thread_exec(       void _async_thread_exec(
          PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),          PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
          void *parm) ;          void *parm) ;
   
 }; };
  
  

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