albaAgentEventQueue.h

Go to the documentation of this file.

/*=========================================================================
 
 Program: ALBA (Agile Library for Biomedical Applications)
 Module: albaAgentEventQueue
 Authors: Marco Petrone
 
 Copyright (c) BIC
 All rights reserved. See Copyright.txt or
 
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
 
#ifndef __albaAgentEventQueue_h
#define __albaAgentEventQueue_h
 
#include "albaAgent.h"
 
 
//----------------------------------------------------------------------------
// forward declarations
//----------------------------------------------------------------------------
class albaMutexLock;
 
class ALBA_EXPORT albaAgentEventQueue : public albaAgent
{
public:
  //------------------------------------------------------------------------------
  // Events
  //------------------------------------------------------------------------------
  ALBA_ID_DEC(EVENT_DISPATCH);
 
  enum DispatchModalities {
    SelfProcessMode = 0,
    BroadcastMode
  };
 
  enum PopModalities {
    SingleEventMode = 0,
    MultipleEventMode
  };
 
  enum PushModalities {
    DispatchEventMode=0,
    PollingMode
  };
 
  albaTypeMacro(albaAgentEventQueue,albaAgent);
 
  bool PushEvent(albaEventBase &event) {return PushEvent(&event);}
  virtual bool PushEvent(albaEventBase *event);
  bool PushEvent(albaID event_id, void *sender, void *data=NULL);
 
  albaEventBase *PeekEvent();
  
  albaEventBase *PeekLastEvent();
 
  int GetQueueSize();
 
  bool IsQueueEmpty() {return this->GetQueueSize()==0;}
 
  virtual bool DispatchEvents(); 
 
  void SetDequeueMode(int mode) {m_DequeueMode=mode;}
  int GetDequeueMode() {return m_DequeueMode;}
  void SetDequeueModeToMultipleEvent() {SetDequeueMode(MultipleEventMode);}
  void SetDequeueModeToSingleEvent() {SetDequeueMode(SingleEventMode);}
 
  void SetDispatchMode(int mode) {m_DispatchMode=mode;}
  int GetDispatchMode() {return m_DispatchMode;}
  void SetDispatchModeToSelfProcess() {SetDispatchMode(SelfProcessMode);}
  void SetDispatchModeToBroadcast() {SetDispatchMode(BroadcastMode);}
 
  void SetPushMode(int mode) {m_PushMode=mode;}
  int GetPushMode() {return m_PushMode;}
  void SetPushModeToDispatchEvent() {m_PushMode=DispatchEventMode;}
  void SetPushModeToPolling() {m_PushMode=PollingMode;}
 
protected:
  albaAgentEventQueue();
  virtual ~albaAgentEventQueue();
 
  //------------------------------------------------------------------------------
  // Forward declarations
  //------------------------------------------------------------------------------
  class EventQueueItem;
  struct InternalEventQueue;
 
  albaEventBase *PopEvent();
  int PopEvent(albaEventBase &event);
  virtual int PopEvent(albaEventBase *&event);
 
  bool GetDispatched() {return m_Dispatched;}
  void SetDispatched(bool value=true);
 
  //virtual void SetListener(albaAgent *listener) {this->Superclass::SetListener(listener);}
 
  virtual void RequestForDispatching();
 
  InternalEventQueue *m_EventQueue;
 
  albaMutexLock *m_Mutex;
 
  int m_DispatchMode;
  int m_DequeueMode;
  int m_PushMode;
 
  bool m_Dispatched;
 
private:
  albaAgentEventQueue(const albaAgentEventQueue&);  // Not implemented.
  void operator=(const albaAgentEventQueue&);  // Not implemented.
 
};
 
 
#endif