version 1.6, 2002/03/21 22:53:10
|
version 1.7, 2002/03/22 19:51:37
|
|
|
| |
class ModuleController; | class ModuleController; |
| |
|
|
|
|
class PEGASUS_COMMON_LINKAGE pegasus_module |
|
{ |
|
class PEGASUS_COMMON_LINKAGE module_rep | class PEGASUS_COMMON_LINKAGE module_rep |
{ | { |
public: | public: |
module_rep(ModuleController *controller, | module_rep(ModuleController *controller, |
const String & name, | const String & name, |
void *module_address, | void *module_address, |
Boolean (*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(), | : _thread_safety(), |
|
|
_shutdown_notify = default_shutdown_notify; | _shutdown_notify = default_shutdown_notify; |
} | } |
| |
virtual ~module_rep(void) |
~module_rep(void) |
{ | { |
| |
} | } |
|
|
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; } |
Boolean module_receive_message(Message *msg) |
Message * module_receive_message(Message *msg) |
{ | { |
Boolean ret; |
Message * ret; |
_thread_safety.lock(pegasus_thread_self()); | _thread_safety.lock(pegasus_thread_self()); |
try { ret = _receive_message(msg); } | try { ret = _receive_message(msg); } |
catch(...) { _thread_safety.unlock(); throw; } | catch(...) { _thread_safety.unlock(); throw; } |
|
|
Uint32 _shutting_down; | Uint32 _shutting_down; |
| |
void *_module_address; | void *_module_address; |
Boolean (*_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); |
| |
static Boolean default_receive_message(Message *msg) |
static Message * default_receive_message(Message *msg) |
{ | { |
throw NotImplemented("Module Receive"); | throw NotImplemented("Module Receive"); |
} | } |
|
|
friend class ModuleController; | friend class ModuleController; |
}; | }; |
| |
|
|
|
class PEGASUS_COMMON_LINKAGE pegasus_module |
|
{ |
|
|
public: | public: |
| |
pegasus_module(ModuleController *controller, | pegasus_module(ModuleController *controller, |
const String &id, | const String &id, |
void *module_address, | void *module_address, |
Boolean (*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)) ; |
| |
|
|
private: | private: |
| |
module_rep *_rep; | module_rep *_rep; |
|
|
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 *) ; |
Boolean _receive_message(Message *msg) |
Message * _receive_message(Message *msg) |
{ | { |
return _rep->module_receive_message(msg); | return _rep->module_receive_message(msg); |
} | } |
|
|
}; | }; |
| |
| |
|
|
|
|
class PEGASUS_COMMON_LINKAGE ModuleController : public MessageQueueService | class PEGASUS_COMMON_LINKAGE ModuleController : public MessageQueueService |
{ | { |
| |
|
|
struct timeval & deadlock); | struct timeval & deadlock); |
| |
| |
virtual ~ModuleController(void); |
~ModuleController(void); |
| |
// module api | // module api |
ModuleController & register_module(const String & module_name, | ModuleController & register_module(const String & module_name, |
void *module_address, | void *module_address, |
Boolean (*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); |
| |
Boolean 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, const String & name) throw(Permission); |
String & find_service(pegasus_module & handle, Uint32 queue_id); |
|
|
Uint32 find_module_in_service(pegasus_module & handle, |
|
const String & module_name) |
|
throw(Permission, IPCException); |
| |
pegasus_module & get_module_reference(pegasus_module & handle, String & name); |
|
|
pegasus_module * get_module_reference(pegasus_module & my_handle, |
|
const String & module_name) |
|
throw(Permission); |
| |
// send a message to another service | // send a message to another service |
Message *ModuleSendWait(pegasus_module & handle, |
AsyncReply *ModuleSendWait(pegasus_module & handle, |
Uint32 destination_q, | Uint32 destination_q, |
Message *message); |
AsyncRequest *request) throw(Permission, IPCException); |
| |
// send a message to another module via another service | // send a message to another module via another service |
Message *ModuleSendWait(pegasus_module & handle, |
AsyncReply *ModuleSendWait(pegasus_module & handle, |
Uint32 destination_q, | Uint32 destination_q, |
String & destination_module, | String & destination_module, |
Message *message); |
AsyncRequest *message) throw(Permission, Deadlock, IPCException); |
| |
// send a message to another service | // send a message to another service |
Boolean ModuleSendAsync(pegasus_module & handle, | Boolean ModuleSendAsync(pegasus_module & handle, |
Uint32 msg_handle, | Uint32 msg_handle, |
Uint32 destination_q, | Uint32 destination_q, |
Message *message); |
AsyncMessage *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, |
Message *message); |
AsyncMessage *message) throw(Permission, IPCException); |
| |
Uint32 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 *), |
void *parm); |
void *parm) throw(Permission, Deadlock, IPCException); |
Uint32 async_thread_exec(pegasus_module & handle, |
void async_thread_exec(pegasus_module & handle, |
PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *), | PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *), |
void *parm); |
void *parm) throw(Permission, Deadlock, IPCException); |
|
Boolean verify_handle(pegasus_module *); |
protected: | protected: |
| |
private: | private: |
| |
|
|
|
static void _async_handleEnqueue(AsyncOpNode *h, MessageQueue *q, void *parm); |
|
|
DQueue<pegasus_module> _modules; | DQueue<pegasus_module> _modules; |
ThreadPool _thread_pool; | ThreadPool _thread_pool; |
}; | }; |