Logo ROOT   6.19/01
Reference Guide
TSysEvtHandler.h
Go to the documentation of this file.
1 // @(#)root/base:$Id$
2 // Author: Fons Rademakers 16/09/95
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #ifndef ROOT_TSysEvtHandler
13 #define ROOT_TSysEvtHandler
14 
15 
16 //////////////////////////////////////////////////////////////////////////
17 // //
18 // TSysEvtHandler //
19 // //
20 // Abstract base class for handling system events. //
21 // //
22 //////////////////////////////////////////////////////////////////////////
23 
24 #include "TObject.h"
25 #include "TQObject.h"
26 
27 
28 class TSysEvtHandler : public TObject, public TQObject {
29 
30 private:
31  Bool_t fIsActive; // kTRUE if handler is active, kFALSE if not active
32 
33  void *GetSender() { return this; } //used to set gTQSender
34 
35 public:
37  virtual ~TSysEvtHandler() { }
38 
39  void Activate();
40  void DeActivate();
41  Bool_t IsActive() const { return fIsActive; }
42 
43  virtual void Add() = 0;
44  virtual void Remove() = 0;
45  virtual Bool_t Notify() = 0;
46 
47  virtual void Activated() { Emit("Activated()"); } //*SIGNAL*
48  virtual void DeActivated() { Emit("DeActivated()"); } //*SIGNAL*
49  virtual void Notified() { Emit("Notified()"); } //*SIGNAL*
50  virtual void Added() { Emit("Added()"); } //*SIGNAL*
51  virtual void Removed() { Emit("Removed()"); } //*SIGNAL*
52 
53  ClassDef(TSysEvtHandler,0) //ABC for handling system events
54 };
55 
56 
57 //////////////////////////////////////////////////////////////////////////
58 // //
59 // TFileHandler //
60 // //
61 // Handles events on file descriptors. //
62 // //
63 //////////////////////////////////////////////////////////////////////////
64 
65 class TFileHandler : public TSysEvtHandler {
66 
67 protected:
68  int fFileNum; //File descriptor
69  int fMask; //Event interest mask, either bit 1 (read), 2 (write) or both can be set
70  int fReadyMask; //Readiness mask, either bit 1 (read), 2 (write) or both can be set
71 
73 
74 public:
75  enum { kRead = 1, kWrite = 2 };
76 
77  TFileHandler(int fd, int mask);
78  virtual ~TFileHandler() { Remove(); }
79  int GetFd() const { return fFileNum; }
80  void SetFd(int fd) { fFileNum = fd; }
81  virtual Bool_t Notify();
82  virtual Bool_t ReadNotify();
83  virtual Bool_t WriteNotify();
84  virtual Bool_t HasReadInterest();
85  virtual Bool_t HasWriteInterest();
86  virtual void SetInterest(Int_t mask);
87  virtual void ResetReadyMask() { fReadyMask = 0; }
88  virtual void SetReadReady() { fReadyMask |= 0x1; }
89  virtual void SetWriteReady() { fReadyMask |= 0x2; }
90  virtual Bool_t IsReadReady() const { return (fReadyMask & 0x1) == 0x1; }
91  virtual Bool_t IsWriteReady() const { return (fReadyMask & 0x2) == 0x2; }
92  virtual void Add();
93  virtual void Remove();
94 
95  ClassDef(TFileHandler,0) //Handles events on file descriptors
96 };
97 
98 
99 //////////////////////////////////////////////////////////////////////////
100 // //
101 // TSignalHandler //
102 // //
103 // Handles signals. //
104 // //
105 //////////////////////////////////////////////////////////////////////////
106 
107 enum ESignals {
124 };
125 
126 
128 
129 protected:
130  ESignals fSignal; //Signal to be handled
131  Bool_t fSync; //Synchronous or a-synchronous signal
132  Int_t fDelay; //Delay handling of signal (use fDelay in Notify())
133 
135 
136 public:
137  TSignalHandler(ESignals sig, Bool_t sync = kTRUE);
138  virtual ~TSignalHandler() { Remove(); }
139  void Delay() { fDelay = 1; }
140  void HandleDelayedSignal();
141  ESignals GetSignal() const { return fSignal; }
142  void SetSignal(ESignals sig) { fSignal = sig; }
143  Bool_t IsSync() const { return fSync; }
144  Bool_t IsAsync() const { return !fSync; }
145  virtual Bool_t Notify();
146  virtual void Add();
147  virtual void Remove();
148 
149  ClassDef(TSignalHandler,0) //Signal event handler
150 };
151 
153 {
154  if (fDelay > 1) {
155  fDelay = 0;
156  Notify();
157  } else
158  fDelay = 0;
159 }
160 
161 
162 //////////////////////////////////////////////////////////////////////////
163 // //
164 // TStdExceptionHandler //
165 // //
166 // Handles standard C++ exceptions. //
167 // //
168 //////////////////////////////////////////////////////////////////////////
169 
170 namespace std { class exception; }
171 
173 
174 public:
176 
178  virtual ~TStdExceptionHandler() { }
179 
180  virtual void Add();
181  virtual void Remove();
182  virtual Bool_t Notify();
183 
184  virtual EStatus Handle(std::exception& exc) = 0;
185 
186  ClassDef(TStdExceptionHandler,0) //C++ exception handler
187 };
188 
189 #endif
virtual void SetWriteReady()
virtual ~TSignalHandler()
virtual ~TStdExceptionHandler()
virtual void DeActivated()
virtual Bool_t Notify()
Notify when event occurred on descriptor associated with this handler.
virtual void Add()=0
void Activate()
Activate a system event handler.
virtual ~TFileHandler()
virtual void Add()
Add signal handler to system signal handler list.
This is the ROOT implementation of the Qt object communication mechanism (see also http://www...
Definition: TQObject.h:48
virtual void Remove()
Remove std::exception handler from system handler list.
virtual void Add()
Add file event handler to system file handler list.
int Int_t
Definition: RtypesCore.h:41
virtual void Notified()
bool Bool_t
Definition: RtypesCore.h:59
STL namespace.
virtual void ResetReadyMask()
void SetSignal(ESignals sig)
void DeActivate()
De-activate a system event handler.
virtual Bool_t IsWriteReady() const
virtual Bool_t Notify()
Notify when signal occurs.
static const double x2[5]
void * GetSender()
virtual Bool_t IsReadReady() const
#define ClassDef(name, id)
Definition: Rtypes.h:326
virtual void Added()
virtual void Removed()
Bool_t IsSync() const
virtual EStatus Handle(std::exception &exc)=0
virtual Bool_t WriteNotify()
Notify when something can be written to the descriptor associated with this handler.
ESignals
Bool_t IsAsync() const
virtual Bool_t HasWriteInterest()
True if handler is interested in write events.
Bool_t IsActive() const
virtual void SetReadReady()
Abstract base class for handling system events.
virtual void Remove()=0
int GetFd() const
ESignals GetSignal() const
void HandleDelayedSignal()
static const double x1[5]
virtual void Activated()
void SetFd(int fd)
virtual void Remove()
Remove signal handler from system signal handler list.
virtual void Remove()
Remove file event handler from system file handler list.
Mother of all ROOT objects.
Definition: TObject.h:37
virtual void SetInterest(Int_t mask)
Set interest mask to 'mask'.
virtual ~TSysEvtHandler()
virtual Bool_t ReadNotify()
Notify when something can be read from the descriptor associated with this handler.
void Emit(const char *signal, const T &arg)
Activate signal with single parameter.
Definition: TQObject.h:164
virtual Bool_t Notify()=0
This method must be overridden to handle object notification.
TStdExceptionHandler()
Handle standard C++ exceptions intercepted by the TSystem::Run().
const Bool_t kTRUE
Definition: RtypesCore.h:87
virtual void Add()
Add std::exception handler to system handler list.
virtual Bool_t Notify()
Notify when signal occurs.
virtual Bool_t HasReadInterest()
True if handler is interested in read events.