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

Diff for /pegasus/src/Pegasus/Common/MessageQueueService.h between version 1.2 and 1.14

version 1.2, 2002/01/18 19:27:48 version 1.14, 2002/02/19 18:21:14
Line 40 
Line 40 
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   extern const Uint32 CIMOM_Q_ID;
   
   class message_module;
  
 class PEGASUS_COMMON_LINKAGE MessageQueueService : public MessageQueue class PEGASUS_COMMON_LINKAGE MessageQueueService : public MessageQueue
 { {
Line 47 
Line 50 
  
       typedef MessageQueue Base;       typedef MessageQueue Base;
  
       MessageQueueService(const char *name, Uint32 queueID, Uint32 capabilities, Uint32 mask) ;        MessageQueueService(const char *name, Uint32 queueID,
                             Uint32 capabilities = 0,
                             Uint32 mask = message_mask::type_cimom |
                             message_mask::type_service |
                             message_mask::ha_request |
                             message_mask::ha_reply |
                             message_mask::ha_async ) ;
  
       virtual ~MessageQueueService(void);       virtual ~MessageQueueService(void);
  
       // don't allow derived classes to override  
       void handleEnqueue();  
       virtual void handle_heartbeat_request(AsyncRequest *req);       virtual void handle_heartbeat_request(AsyncRequest *req);
       virtual void handle_heartbeat_reply(AsyncReply *rep);       virtual void handle_heartbeat_reply(AsyncReply *rep);
  
Line 63 
Line 70 
       virtual void handle_CimServiceResume(CimServiceResume *req);       virtual void handle_CimServiceResume(CimServiceResume *req);
  
       virtual void handle_AsyncOperationStart(AsyncOperationStart *req);       virtual void handle_AsyncOperationStart(AsyncOperationStart *req);
       virtual void handle_AsyncOperationResult(AsyncOperationResult *req);        virtual void handle_AsyncOperationResult(AsyncOperationResult *rep);
         virtual void handle_AsyncLegacyOperationStart(AsyncLegacyOperationStart *req);
 //     virtual Boolean accept_async(Message *message) throw(IPCException);        virtual void handle_AsyncLegacyOperationResult(AsyncLegacyOperationResult *rep);
 //     virtual Boolean messageOK(const Message *msg) ;  
         virtual Boolean isAsync(void) {  return true;  }
 //      virtual Message *openEnvelope(Message *msg);  
         virtual Boolean accept_async(AsyncOpNode *op);
         virtual Boolean messageOK(const Message *msg) ;
   
         AsyncReply *SendWait(AsyncRequest *request);
         Boolean SendAsync(AsyncOpNode *op,
                           Uint32 destination,
                           void (*callback)(AsyncOpNode *, MessageQueue *, void *));
         Boolean  SendForget(Message *msg);
  
       AsyncMessage *SendWait(AsyncRequest *request);        void _completeAsyncResponse(AsyncRequest *request,
   
       void SendWait(AsyncRequest *request, unlocked_dq<AsyncMessage> *reply_list);  
 //      Boolean SendAsync(AsyncMessage *msg);  
       void _enqueueAsyncResponse(AsyncRequest *request,  
                                  AsyncReply *reply,                                  AsyncReply *reply,
                                  Uint32 state,                                  Uint32 state,
                                  Uint32 flag);                                  Uint32 flag);
       Boolean register_service(String name, Uint32 capabilities, Uint32 mask);       Boolean register_service(String name, Uint32 capabilities, Uint32 mask);
       Boolean update_service(Uint32 capabilities, Uint32 mask);       Boolean update_service(Uint32 capabilities, Uint32 mask);
       Boolean deregister_service(void);       Boolean deregister_service(void);
         virtual void _shutdown_incoming_queue(void);
       void find_services(String name,       void find_services(String name,
                          Uint32 capabilities,                          Uint32 capabilities,
                          Uint32 mask,                          Uint32 mask,
Line 94 
Line 105 
       Uint32 _mask;       Uint32 _mask;
       AtomicInt _die;       AtomicInt _die;
    protected:    protected:
         virtual void handleEnqueue(void);
       // handle all your messages. call Base:_handle_async_msg to        virtual void handleEnqueue(Message *);
       // deal with messages you don't handle        virtual Boolean _enqueueResponse(Message *, Message *);
       virtual void _handle_async_msg(AsyncMessage *msg);        virtual void _handle_incoming_operation(AsyncOpNode *operation, Thread *thread, MessageQueue *queue);
         virtual void _handle_async_request(AsyncRequest *req);
         virtual void _make_response(Message *req, Uint32 code);
   
         static cimom *_meta_dispatcher;
         static AtomicInt _service_count;
         static Mutex _meta_dispatcher_mutex;
  
  
       cimom *_meta_dispatcher;  
    private:    private:
  
         DQueue<AsyncOpNode> _pending;
         AsyncDQueue<AsyncOpNode> _incoming;
   
         static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL _req_proc(void *);
         AtomicInt _incoming_queue_shutdown;
   
         Thread _req_thread;
  
       struct timeval _default_op_timeout;       struct timeval _default_op_timeout;
  
       static AtomicInt _xid;       static AtomicInt _xid;
       void _handle_async_request(AsyncRequest *req);  
       void _handle_async_reply(AsyncReply *rep);  
       void _make_response(AsyncRequest *req, Uint32 code);  
   
 }; };
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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