(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.4 and 1.5

version 1.4, 2002/03/20 21:25:49 version 1.5, 2002/03/21 16:10:00
Line 43 
Line 43 
 class ModuleController; class ModuleController;
  
  
   
 class PEGASUS_COMMON_LINKAGE pegasus_module class PEGASUS_COMMON_LINKAGE pegasus_module
 { {
       class  module_rep;        class PEGASUS_COMMON_LINKAGE module_rep
   
    public:  
   
       pegasus_module(ModuleController *controller,  
                      const String &id,  
                      void *module_address,  
                      void (*_async_callback)(Uint32, Message *)) ;  
   
       pegasus_module(const pegasus_module & mod);  
   
   
       virtual ~pegasus_module();  
   
       pegasus_module & operator= (const pegasus_module & mod);  
       Boolean operator == (const pegasus_module *mod) const;  
       Boolean operator == (const pegasus_module & mod) const ;  
       Boolean operator == (const String &  mod) const;  
       Boolean operator == (const void *mod) const;  
   
       const String & get_name(void);  
   
       // introspection interface  
       Boolean query_interface(String & class_id, void **object_ptr) ;  
   
    private:  
   
       module_rep *_rep;  
   
       pegasus_module(void);  
       virtual Boolean _rcv_msg(Message *) = 0;  
       void _send_async_callback(Uint32 msg_handle, Message *msg) ;  
   
       virtual Boolean _shutdown(Uint32) = 0;  
   
       virtual Uint32 reference(void) { _reference_count++; }  
       virtual Uint32 dereference(void)  { _reference_count--; }  
   
       friend class ModuleController;  
 };  
   
   
 class PEGASUS_COMMON_LINKAGE pegasus_module::module_rep  
 { {
    public:    public:
       module_rep(ModuleController *controller,       module_rep(ModuleController *controller,
                  const String & name,                  const String & name,
                  void *module_address,                  void *module_address,
                  void (*async_callback)(Uint32, Message *))                         Boolean (*receive_message)(Message *),
          : _controller(controller),                         void (*async_callback)(Uint32, Message *),
                          void (*shutdown_notify)(Uint32 code))
                  : _thread_safety(),
                    _controller(controller),
            _name(name),            _name(name),
            _reference_count(1),            _reference_count(1),
            _module_address(module_address),                   _module_address(module_address)
            _async_callback(async_callback)  
       {  
  
               {
                  if(receive_message != NULL)
                     _receive_message = receive_message;
                  else
                     _receive_message = default_receive_message;
                  if(async_callback != NULL)
                     _async_callback = async_callback;
                  else
                     _async_callback = default_async_callback;
                  if(shutdown_notify != NULL)
                     _shutdown_notify = shutdown_notify;
                  else
                     _shutdown_notify = default_shutdown_notify;
       }       }
  
       virtual ~module_rep(void)       virtual ~module_rep(void)
Line 130 
Line 103 
          return false;          return false;
       }       }
  
               void reference(void) { _reference_count++; }
               void dereference(void) { _reference_count--; }
               Uint32 reference_count(void)  { return _reference_count.value(); }
               const String & get_name(void) const { return _name; }
               void *get_module_address(void) const { return _module_address; }
               Boolean module_receive_message(Message *msg)
               {
  
                  _thread_safety.lock(pegasus_thread_self());
                  try {  _receive_message(msg); }
                  catch(...) { _thread_safety.unlock(); throw; }
                  _thread_safety.unlock();
               }
  
               void _send_async_callback(Uint32 msg_handle, Message *msg)
               {
                  _thread_safety.lock(pegasus_thread_self());
                  try  { _async_callback(msg_handle, msg); }
                  catch(...) { _thread_safety.unlock(); throw; }
   
               }
               void _send_shutdown_notify(Uint32 code)
               {
                  _shutdown_notify(code);
               }
               void lock(void)
               {
                  _thread_safety.lock(pegasus_thread_self());
               }
   
               void unlock(void)
               {
                  _thread_safety.unlock();
               }
  
    private:    private:
       module_rep(void);       module_rep(void);
       module_rep(const module_rep & );       module_rep(const module_rep & );
       module_rep& operator= (const module_rep & );       module_rep& operator= (const module_rep & );
  
               Mutex _thread_safety;
       ModuleController *_controller;       ModuleController *_controller;
       String _name;       String _name;
       AtomicInt _reference_count;       AtomicInt _reference_count;
       void *_module_address;       void *_module_address;
               Boolean (*_receive_message)(Message *);
       void (*_async_callback)(Uint32, Message *);       void (*_async_callback)(Uint32, Message *);
               void (*_shutdown_notify)(Uint32 code);
   
               static Boolean default_receive_message(Message *msg)
               {
                  throw NotImplemented("Module Receive");
               }
   
               static void default_async_callback(Uint32 handle, Message *msg)
               {
                  throw NotImplemented("Module Async Receive");
               }
   
               static void default_shutdown_notify(Uint32 code)
               {
                  return;
               }
   
               friend class ModuleController;
         };
   
      public:
   
         pegasus_module(ModuleController *controller,
                        const String &id,
                        void *module_address,
                        Boolean (*receive_message)(Message *),
                        void (*async_callback)(Uint32, Message *),
                        void (*shutdown_notify)(Uint32 code)) ;
   
         virtual ~pegasus_module(void)
         {
            _rep->dereference();
            if( 0 == _rep->reference_count())
               delete _rep;
         }
   
         pegasus_module & operator= (const pegasus_module & mod);
         Boolean operator == (const pegasus_module *mod) const;
         Boolean operator == (const pegasus_module & mod) const ;
         Boolean operator == (const String &  mod) const;
         Boolean operator == (const void *mod) const;
   
         const String & get_name(void) const;
   
         // introspection interface
         Boolean query_interface(const String & class_id, void **object_ptr) const;
   
      private:
   
         module_rep *_rep;
   
         pegasus_module(void);
         pegasus_module(const pegasus_module & mod);
         virtual Boolean _rcv_msg(Message *) ;
         Boolean _receive_message(Message *msg)
         {
            _rep->module_receive_message(msg);
         }
   
         void _send_async_callback(Uint32 msg_handle, Message *msg)
         {
            _rep->_send_async_callback(msg_handle, msg);
         }
         void _send_shutdown_notify(Uint32 code)
         {
            _rep->_send_shutdown_notify(code);
         }
   
         virtual Boolean _shutdown(Uint32) ;
         virtual void reference(void) { _rep->reference(); }
         virtual void dereference(void)  { _rep->dereference(); }
   
       friend class ModuleController;       friend class ModuleController;
 }; };
  
  
   
   
 class PEGASUS_COMMON_LINKAGE ModuleController : public MessageQueueService class PEGASUS_COMMON_LINKAGE ModuleController : public MessageQueueService
 { {
  
    public:    public:
       typedef MesageQueueService Base;        typedef MessageQueueService Base;
  
       ModuleController(const char *name, Uint32 queueID);       ModuleController(const char *name, Uint32 queueID);
       virtual ~ModuleController(void);       virtual ~ModuleController(void);
Line 162 
Line 242 
                                          void *module_address,                                          void *module_address,
                                          void (*async_callback)(Uint32, Message *));                                          void (*async_callback)(Uint32, Message *));
  
       deregister_module(const String & module_name);        Boolean deregister_module(const String & module_name);
  
       Uint32 find_service(pegasus_module & handle, String & name);       Uint32 find_service(pegasus_module & handle, String & name);
       String & find_service(pegasus_module & handle, Uint32 queue_id);       String & find_service(pegasus_module & handle, Uint32 queue_id);
Line 209 
Line 289 
 }; };
  
  
 pegasus_module(const pegasus_module & mod)  
 {  
    (mod._rep->_reference_count)++;  
    _rep = mod._rep;  
 }  
   
 virtual ~pegasus_module()  
 {  
    if( 0 == (_rep->_reference_count.value()))  
       delete _rep;  
   
 }  
   
   
 pegasus_module & pegasus_module::operator= (const pegasus_module & mod)  
 {  
    (mod._rep->_reference_count)++;  
    if ( ((rep->_reference_count)--) == 0 )  
       delete rep;  
    _rep = mod._rep;  
    return *this;  
 }  
   
 Boolean pegasus_module::operator== (const pegasus_module *mod) const  
 {  
    if(mod->_rep == _rep)  
       return true;  
    return false;  
 }  
   
   
 Boolean pegasus_module::operator== (const pegasus_module & mod) const  
 {  
    if( mod._rep == _rep )  
       return true;  
    return false;  
   
 }  
   
 Boolean pegasus_module::operator == (const String &  mod) const  
 {  
    if(_rep->_name == mod)  
       return true;  
    return false;  
 }  
   
   
 Boolean pegasus_module::operator == (const void *mod) const  
 {  
    if ( (reinterpret_cast<pegasus_module *>(mod))->_rep == _rep)  
       return true;  
    return false;  
 }  
   
 Boolean pegasus_module::operator == (const void *mod) const  
 {  
    if ( (reinterpret_cast<pegasus_module *>(mod))->_rep == _rep)  
       return true;  
    return false;  
 }  
  
  
  

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