Logo ROOT  
Reference Guide
TTimer.h
Go to the documentation of this file.
1// @(#)root/base:$Id$
2// Author: Fons Rademakers 28/11/96
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_TTimer
13#define ROOT_TTimer
14
15
16//////////////////////////////////////////////////////////////////////////
17// //
18// TTimer //
19// //
20// Handles synchronous and a-synchronous timer events. You can use //
21// this class in one of the following ways: //
22// - Sub-class TTimer and override the Notify() method. //
23// - Re-implement the TObject::HandleTimer() method in your class //
24// and pass a pointer to this object to timer, see the SetObject() //
25// method. //
26// - Pass an interpreter command to timer, see SetCommand() method. //
27// - Create a TTimer, connect its Timeout() signal to the //
28// appropriate methods. Then when the time is up it will emit a //
29// Timeout() signal and call connected slots. //
30// //
31// Minimum timeout interval is defined in TSystem::ESysConstants as //
32// kItimerResolution (currently 10 ms). //
33// //
34// Signal/slots example: //
35// TTimer *timer = new TTimer(); //
36// timer->Connect("Timeout()", "myObjectClassName", //
37// myObject, "TimerDone()"); //
38// timer->Start(2000, kTRUE); // 2 seconds single-shot //
39// //
40// // Timeout signal is emitted repeadetly with minimum timeout //
41// // timer->Start(0, kFALSE); //
42// //
43//////////////////////////////////////////////////////////////////////////
44
45#include "TSysEvtHandler.h"
46#include "TTime.h"
47#include "TString.h"
48
49
50
51class TTimer : public TSysEvtHandler {
52
53protected:
54 TTime fTime; // time out time in ms
55 TTime fAbsTime; // absolute time out time in ms
56 Bool_t fTimeout; // true if timer has timed out
57 Bool_t fSync; // true if synchrounous timer
58 Bool_t fIntSyscalls; // true is a-synchronous timer is to interrupt system calls
59 UInt_t fTimeID; // the system ID of this timer (for WIN32)
60 TObject *fObject; // object to be notified (if any)
61 TString fCommand; // interpreter command to be executed
62
63private:
64 TTimer(const TTimer&) = delete;
65 TTimer& operator=(const TTimer&) = delete;
66
67public:
68 TTimer(Long_t milliSec = 0, Bool_t mode = kTRUE);
69 TTimer(TObject *obj, Long_t milliSec, Bool_t mode = kTRUE);
70 TTimer(const char *command, Long_t milliSec, Bool_t mode = kTRUE);
71 virtual ~TTimer() { Remove(); }
72
73 Bool_t CheckTimer(const TTime &now);
74 const char *GetCommand() const { return fCommand.Data(); }
75 TObject *GetObject() { return fObject; }
76 TTime GetTime() const { return fTime; }
78 TTime GetAbsTime() const { return fAbsTime; }
79 Bool_t HasTimedOut() const { return fTimeout; }
80 Bool_t IsSync() const { return fSync; }
81 Bool_t IsAsync() const { return !fSync; }
84 virtual Bool_t Notify();
85 void Add() { TurnOn(); }
86 void Remove() { TurnOff(); }
87 void Reset();
88 void SetCommand(const char *command);
89 void SetObject(TObject *object);
91 void SetTime(Long_t milliSec) { fTime = milliSec; }
92 void SetTimerID(UInt_t id = 0) { fTimeID = id; }
93 virtual void Start(Long_t milliSec = -1, Bool_t singleShot = kFALSE);
94 virtual void Stop() { TurnOff(); }
95 virtual void TurnOn(); //*SIGNAL*
96 virtual void TurnOff(); //*SIGNAL*
97 virtual void Timeout() { Emit("Timeout()"); } //*SIGNAL*
98
99 static void SingleShot(Int_t milliSec, const char *receiver_class,
100 void *receiver, const char *method);
101
102 ClassDef(TTimer,0) //Handle timer event
103};
104
105#endif
int Int_t
Definition: CPyCppyy.h:43
unsigned int UInt_t
Definition: CPyCppyy.h:44
long Long_t
Definition: CPyCppyy.h:50
const Bool_t kFALSE
Definition: RtypesCore.h:101
bool Bool_t
Definition: RtypesCore.h:63
const Bool_t kTRUE
Definition: RtypesCore.h:100
#define ClassDef(name, id)
Definition: Rtypes.h:325
Mother of all ROOT objects.
Definition: TObject.h:37
void Emit(const char *signal, const T &arg)
Activate signal with single parameter.
Definition: TQObject.h:164
Basic string class.
Definition: TString.h:136
const char * Data() const
Definition: TString.h:369
Abstract base class for handling system events.
Basic time type with millisecond precision.
Definition: TTime.h:27
Handles synchronous and a-synchronous timer events.
Definition: TTimer.h:51
TTime GetAbsTime() const
Definition: TTimer.h:78
virtual void TurnOff()
Remove timer from system timer list.
Definition: TTimer.cxx:229
virtual void Start(Long_t milliSec=-1, Bool_t singleShot=kFALSE)
Starts the timer with a milliSec timeout.
Definition: TTimer.cxx:211
virtual ~TTimer()
Definition: TTimer.h:71
void SetTimerID(UInt_t id=0)
Definition: TTimer.h:92
virtual void TurnOn()
Add the timer to the system timer list.
Definition: TTimer.cxx:241
void SetCommand(const char *command)
Set the interpreter command to be executed at time out.
Definition: TTimer.cxx:174
TString fCommand
Definition: TTimer.h:61
void SetInterruptSyscalls(Bool_t set=kTRUE)
When the argument is true the a-synchronous timer (SIGALRM) signal handler is set so that interrupted...
Definition: TTimer.cxx:197
Bool_t IsAsync() const
Definition: TTimer.h:81
TTime fTime
Definition: TTimer.h:54
void Reset()
Reset the timer.
Definition: TTimer.cxx:157
Bool_t CheckTimer(const TTime &now)
Check if timer timed out.
Definition: TTimer.cxx:128
void SetObject(TObject *object)
Set the object to be notified at time out.
Definition: TTimer.cxx:184
static void SingleShot(Int_t milliSec, const char *receiver_class, void *receiver, const char *method)
This static function calls a slot after a given time interval.
Definition: TTimer.cxx:256
TObject * fObject
Definition: TTimer.h:60
const char * GetCommand() const
Definition: TTimer.h:74
void SetTime(Long_t milliSec)
Definition: TTimer.h:91
TTime fAbsTime
Definition: TTimer.h:55
Bool_t IsInterruptingSyscalls() const
Definition: TTimer.h:82
virtual Bool_t Notify()
Notify when timer times out.
Definition: TTimer.cxx:143
Bool_t HasTimedOut() const
Definition: TTimer.h:79
TTime GetTime() const
Definition: TTimer.h:76
TObject * GetObject()
Definition: TTimer.h:75
Bool_t fTimeout
Definition: TTimer.h:56
TTimer(const TTimer &)=delete
Bool_t IsSync() const
Definition: TTimer.h:80
Bool_t fSync
Definition: TTimer.h:57
Bool_t IsRunning()
This function checks if the timer is running within gSystem (Has been started and did not finish yet)...
Definition: TTimer.cxx:277
void Add()
Definition: TTimer.h:85
virtual void Stop()
Definition: TTimer.h:94
TTimer & operator=(const TTimer &)=delete
void Remove()
Definition: TTimer.h:86
UInt_t GetTimerID()
Definition: TTimer.h:77
Bool_t fIntSyscalls
Definition: TTimer.h:58
virtual void Timeout()
Definition: TTimer.h:97
UInt_t fTimeID
Definition: TTimer.h:59