(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.18 and 1.19

version 1.18, 2002/04/02 22:01:58 version 1.19, 2002/04/05 20:10:09
Line 30 
Line 30 
 #define Pegasus_Module_Controller_h #define Pegasus_Module_Controller_h
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
   #include <Pegasus/Common/Constants.h>
 #include <Pegasus/Common/Message.h> #include <Pegasus/Common/Message.h>
 #include <Pegasus/Common/Exception.h> #include <Pegasus/Common/Exception.h>
 #include <Pegasus/Common/IPC.h> #include <Pegasus/Common/IPC.h>
Line 80 
Line 81 
  
             Message * module_receive_message(Message *msg);             Message * module_receive_message(Message *msg);
  
             void _send_async_callback(Uint32 msg_handle, Message *msg);              void _send_async_callback(Uint32 msg_handle, Message *msg, void *parm);
  
             void _send_shutdown_notify(void);             void _send_shutdown_notify(void);
             void lock(void) { _thread_safety.lock(pegasus_thread_self()); }             void lock(void) { _thread_safety.lock(pegasus_thread_self()); }
Line 141 
Line 142 
       virtual Boolean authorized(Uint32 operation);       virtual Boolean authorized(Uint32 operation);
       virtual Boolean authorized(void);       virtual Boolean authorized(void);
  
       Boolean operator == (const pegasus_module *mod) const;  
       Boolean operator == (const pegasus_module & mod) const ;       Boolean operator == (const pegasus_module & mod) const ;
       Boolean operator == (const String &  mod) const;       Boolean operator == (const String &  mod) const;
       Boolean operator == (const void *mod) const;       Boolean operator == (const void *mod) const;
Line 156 
Line 156 
  
       module_rep *_rep;       module_rep *_rep;
  
       pegasus_module(void);        pegasus_module(void)
         {
         }
   
       Boolean _rcv_msg(Message *) ;       Boolean _rcv_msg(Message *) ;
       Message * _receive_message(Message *msg);       Message * _receive_message(Message *msg);
       void _send_async_callback(Uint32 msg_handle, Message *msg) ;        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;       bitset<32> _allowed_operations;
Line 230 
Line 233 
  
       };       };
  
         class callback_handle
         {
            public:
               callback_handle(pegasus_module * module, void *parm)
                  : _module(module), _parm(parm)
               {
               }
   
               ~callback_handle()
               {
                  if( _module->get_name() == String(PEGASUS_CONTROL_TEMP_MODULE) )
                     delete _module;
               }
   
               pegasus_module * _module;
               void *_parm;
         };
   
   
    public:    public:
  
  
Line 244 
Line 266 
  
       ~ModuleController(void);       ~ModuleController(void);
  
       static ModuleController & get_client_handle(const String & controller_name,  
                                                   void **handle);  
  
  
       // module api       // module api
Line 256 
Line 277 
                                                 void (*async_callback)(Uint32, Message *, void *),                                                 void (*async_callback)(Uint32, Message *, void *),
                                                 void (*shutdown_notify)(Uint32, void *),                                                 void (*shutdown_notify)(Uint32, void *),
                                                 pegasus_module **instance = NULL)                                                 pegasus_module **instance = NULL)
   
          throw(AlreadyExists, IncompatibleTypes);          throw(AlreadyExists, IncompatibleTypes);
  
       Boolean deregister_module(const String & module_name)       Boolean deregister_module(const String & module_name)
Line 287 
Line 309 
       Boolean ModuleSendAsync(pegasus_module & handle,       Boolean ModuleSendAsync(pegasus_module & handle,
                               Uint32 msg_handle,                               Uint32 msg_handle,
                               Uint32 destination_q,                               Uint32 destination_q,
                               AsyncRequest *message) throw(Permission, IPCException);                                AsyncRequest *message,
                                 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(pegasus_module & handle,
                               Uint32 msg_handle,                               Uint32 msg_handle,
                               Uint32 destination_q,                               Uint32 destination_q,
                               String & destination_module,                               String & destination_module,
                               AsyncRequest *message) throw(Permission, IPCException);                                AsyncRequest *message,
                                 void *callback_parm) throw(Permission, IPCException);
  
       void blocking_thread_exec(pegasus_module & handle,       void blocking_thread_exec(pegasus_module & handle,
                                 PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),                                 PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
Line 304 
Line 328 
                              void *parm) throw(Permission, Deadlock, IPCException);                              void *parm) throw(Permission, Deadlock, IPCException);
  
       Boolean verify_handle(pegasus_module *);       Boolean verify_handle(pegasus_module *);
   
         static ModuleController & get_client_handle(const pegasus_identity & id,
                                                     client_handle **handle)
            throw(IncompatibleTypes);
   
         void return_client_handle(client_handle *handle);
   
         // send a message to another service
         AsyncReply *ClientSendWait(const client_handle & handle,
                                    Uint32 destination_q,
                                    AsyncRequest *request)
            throw(Permission, IPCException);
   
         // send a message to another module via another service
         AsyncReply *ClientSendWait(const client_handle & handle,
                                    Uint32 destination_q,
                                    String & destination_module,
                                    AsyncRequest *message)
            throw(Permission, Deadlock, IPCException);
   
         // send an async message to another service
         Boolean ClientSendAsync(const client_handle & handle,
                                 Uint32 msg_handle,
                                 Uint32 destination_q,
                                 AsyncRequest *message,
                                 void (*async_callback)(Uint32, Message *, void *) ,
                                 void *callback_parm)
            throw(Permission, IPCException);
   
         // send an async message to another module via another service
         Boolean ClientSendAsync(const client_handle & handle,
                                 Uint32 msg_handle,
                                 Uint32 destination_q,
                                 String & destination_module,
                                 AsyncRequest *message,
                                 void (*async_callback)(Uint32, Message *, void *),
                                 void *callback_parm )
            throw(Permission, IPCException);
   
         void client_blocking_thread_exec(const client_handle & handle,
                                          PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
                                          void *parm)
            throw(Permission, Deadlock, IPCException);
         void client_async_thread_exec(const client_handle & handle,
                                       PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
                                       void *parm)
            throw(Permission, Deadlock, IPCException);
   
    protected:    protected:
       // ATTN-RK-P2-20010322:  These methods are pure virtual in superclass       // ATTN-RK-P2-20010322:  These methods are pure virtual in superclass
       virtual void handleEnqueue(void) {}       virtual void handleEnqueue(void) {}
Line 311 
Line 383 
       virtual void _handle_async_request(AsyncRequest *rq);       virtual void _handle_async_request(AsyncRequest *rq);
       virtual void _handle_async_callback(AsyncOpNode *op);       virtual void _handle_async_callback(AsyncOpNode *op);
  
   
   
   
    private:    private:
       static void _async_handleEnqueue(AsyncOpNode *h, MessageQueue *q, void *parm);       static void _async_handleEnqueue(AsyncOpNode *h, MessageQueue *q, void *parm);
       DQueue<pegasus_module> _modules;       DQueue<pegasus_module> _modules;
       ThreadPool _thread_pool;       ThreadPool _thread_pool;
         pegasus_module _internal_module;
         AsyncReply *_send_wait(Uint32, AsyncRequest *);
         AsyncReply *_send_wait(Uint32, String &, AsyncRequest *);
         void _blocking_thread_exec(
            PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
            void *parm) ;
         void _async_thread_exec(
            PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
            void *parm) ;
   
 }; };
  
  

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