version 1.8, 2002/03/23 02:15:47
|
version 1.9, 2002/03/26 21:39:06
|
|
|
| |
class ModuleController; | class ModuleController; |
| |
|
|
|
class PEGASUS_COMMON_LINKAGE pegasus_module |
|
{ |
|
private: |
class PEGASUS_COMMON_LINKAGE module_rep | class PEGASUS_COMMON_LINKAGE module_rep |
{ | { |
public: | public: |
|
|
void *module_address, | void *module_address, |
Message * (*receive_message)(Message *), | Message * (*receive_message)(Message *), |
void (*async_callback)(Uint32, Message *), | void (*async_callback)(Uint32, Message *), |
void (*shutdown_notify)(Uint32 code)) |
void (*shutdown_notify)(Uint32 code)); |
: _thread_safety(), |
|
_controller(controller), |
|
_name(name), |
|
_reference_count(1), |
|
_shutting_down(0), |
|
_module_address(module_address) |
|
|
|
{ |
|
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; |
|
} |
|
| |
~module_rep(void) |
~module_rep(void) ; |
{ |
|
| |
} |
|
| |
Boolean operator == (const module_rep *rep) const | Boolean operator == (const module_rep *rep) const |
{ |
{ if (rep == this ) return true; return false; } |
if (rep == this ) |
|
return true; |
|
return false; |
|
} |
|
| |
Boolean operator == (const module_rep &rep) const | Boolean operator == (const module_rep &rep) const |
{ |
{ if (rep == *this) return true; return false; } |
if (rep == *this) |
|
return true; |
|
return false; |
|
} |
|
| |
Boolean operator == (void *rep) const | Boolean operator == (void *rep) const |
{ |
{ if ( (void *)this == rep ) return true; return false; } |
if ( (void *)this == rep ) |
|
return true; |
|
return false; |
|
} |
|
| |
void reference(void) { _reference_count++; } | void reference(void) { _reference_count++; } |
void dereference(void) { _reference_count--; } | void dereference(void) { _reference_count--; } |
Uint32 reference_count(void) { return _reference_count.value(); } | Uint32 reference_count(void) { return _reference_count.value(); } |
const String & get_name(void) const { return _name; } | const String & get_name(void) const { return _name; } |
void *get_module_address(void) const { return _module_address; } | void *get_module_address(void) const { return _module_address; } |
Message * module_receive_message(Message *msg) |
|
{ |
|
Message * ret; |
|
_thread_safety.lock(pegasus_thread_self()); |
|
try { ret = _receive_message(msg); } |
|
catch(...) { _thread_safety.unlock(); throw; } |
|
_thread_safety.unlock(); |
|
return ret; |
|
} |
|
| |
void _send_async_callback(Uint32 msg_handle, Message *msg) |
Message * module_receive_message(Message *msg); |
{ |
|
_thread_safety.lock(pegasus_thread_self()); |
|
try { _async_callback(msg_handle, msg); } |
|
catch(...) { _thread_safety.unlock(); throw; } |
|
| |
} |
void _send_async_callback(Uint32 msg_handle, Message *msg); |
void _send_shutdown_notify(Uint32 code) |
|
{ |
|
_thread_safety.lock(pegasus_thread_self()); |
|
if( _shutting_down == 0 ) |
|
{ |
|
_shutting_down++; |
|
_shutdown_notify(code); |
|
} |
|
_thread_safety.unlock(); |
|
} |
|
void lock(void) |
|
{ |
|
_thread_safety.lock(pegasus_thread_self()); |
|
} |
|
|
|
void unlock(void) |
|
{ |
|
_thread_safety.unlock(); |
|
} |
|
| |
|
void _send_shutdown_notify(void); |
|
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 & ); |
|
|
ModuleController *_controller; | ModuleController *_controller; |
String _name; | String _name; |
AtomicInt _reference_count; | AtomicInt _reference_count; |
Uint32 _shutting_down; |
AtomicInt _shutting_down; |
| |
void *_module_address; | void *_module_address; |
Message * (*_receive_message)(Message *); | Message * (*_receive_message)(Message *); |
|
|
void (*_shutdown_notify)(Uint32 code); | void (*_shutdown_notify)(Uint32 code); |
| |
static Message * default_receive_message(Message *msg) | static Message * default_receive_message(Message *msg) |
{ |
{ throw NotImplemented("Module Receive");} |
throw NotImplemented("Module Receive"); |
|
} |
|
| |
static void default_async_callback(Uint32 handle, Message *msg) | static void default_async_callback(Uint32 handle, Message *msg) |
{ |
{ throw NotImplemented("Module Async Receive"); } |
throw NotImplemented("Module Async Receive"); |
|
} |
|
| |
static void default_shutdown_notify(Uint32 code) | static void default_shutdown_notify(Uint32 code) |
{ |
{ return; } |
return; |
|
} |
|
| |
friend class ModuleController; |
static Message * closed_receive_message(Message *msg) |
}; |
{ throw ModuleClosed();} |
| |
|
static void closed_async_callback(Uint32 handle, Message *msg) |
|
{ throw ModuleClosed(); } |
| |
class PEGASUS_COMMON_LINKAGE pegasus_module |
friend class ModuleController; |
{ |
}; |
| |
public: | public: |
| |
|
|
void (*async_callback)(Uint32, Message *), | void (*async_callback)(Uint32, Message *), |
void (*shutdown_notify)(Uint32 code)) ; | void (*shutdown_notify)(Uint32 code)) ; |
| |
~pegasus_module(void) |
~pegasus_module(void); |
{ |
|
_rep->dereference(); |
|
if( 0 == _rep->reference_count()) |
|
delete _rep; |
|
} |
|
| |
pegasus_module & operator= (const pegasus_module & mod); | pegasus_module & operator= (const pegasus_module & mod); |
Boolean operator == (const pegasus_module *mod) const; | Boolean operator == (const pegasus_module *mod) const; |
|
|
pegasus_module(void); | pegasus_module(void); |
pegasus_module(const pegasus_module & mod); | pegasus_module(const pegasus_module & mod); |
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) ; |
return _rep->module_receive_message(msg); |
void _send_shutdown_notify(void); |
} |
Boolean _shutdown(void); |
|
|
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); |
|
} |
|
|
|
Boolean _shutdown(Uint32 code) { _send_shutdown_notify(code); return true; } |
|
| |
void reference(void) { _rep->reference(); } | void reference(void) { _rep->reference(); } |
void dereference(void) { _rep->dereference(); } | void dereference(void) { _rep->dereference(); } |
|
|
friend class ModuleController; | friend class ModuleController; |
}; | }; |
| |
|
|
~ModuleController(void); | ~ModuleController(void); |
| |
// module api | // module api |
ModuleController & register_module(const String & module_name, |
static ModuleController & register_module(const String & controller_name, |
|
const String & module_name, |
void *module_address, | void *module_address, |
Message * (*receive_message)(Message *), | Message * (*receive_message)(Message *), |
void (*async_callback)(Uint32, Message *), | void (*async_callback)(Uint32, Message *), |
void (*shutdown_notify)(Uint32)) throw(AlreadyExists); |
void (*shutdown_notify)(Uint32)) |
|
throw(AlreadyExists, IncompatibleTypes); |
| |
Boolean deregister_module(const String & module_name); | Boolean deregister_module(const String & module_name); |
| |
|
|
Boolean ModuleSendAsync(pegasus_module & handle, | Boolean ModuleSendAsync(pegasus_module & handle, |
Uint32 msg_handle, | Uint32 msg_handle, |
Uint32 destination_q, | Uint32 destination_q, |
AsyncMessage *message) throw(Permission, IPCException); |
AsyncRequest *message) throw(Permission, IPCException); |
| |
// send a message to another module via another service | // send a 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, |
AsyncMessage *message) throw(Permission, IPCException); |
AsyncRequest *message) 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 *), |
|
|
// 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) {} |
virtual void handleEnqueue(Message *) {} | virtual void handleEnqueue(Message *) {} |
|
virtual void _handle_async_request(AsyncRequest *rq); |
|
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; |
}; | }; |