PIP 1.7.1 Platform-Independent Primitives

Public Types | Public Member Functions | Protected Member Functions | List of all members
PITimer Class Reference

Timer. More...

Inheritance diagram for PITimer:
[legend]

## Public Types
enum | TimerImplementation { Thread = 0x01, ThreadRT = 0x02, Pool = 0x04 }
| Timer implementations. More...

## Public Member Functions
| PITimer ()
| Constructs timer with PITimer::Thread implementation.
| PITimer (TimerImplementation ti)
| Constructs timer with "ti" implementation.
| PITimer (TimerEvent slot, void *data=0, TimerImplementation ti=Thread)
| Constructs timer with "slot" slot, "data" data and "ti" implementation.
PITimer::TimerImplementation | implementation () const
| Returns timer implementation.
double | interval () const
| Returns timer loop delay in milliseconds.
void | setInterval (double ms)
| Set timer loop delay in milliseconds.
bool | isRunning () const
| Returns if timer is started.
bool | isStopped () const
| Returns if timer is not started.
void | startDeferred (double delay_ms)
| Start timer with interval() loop delay after delay_msecs delay. More...
void | startDeferred (double interval_ms, double delay_ms)
| Start timer with interval_msecs loop delay after delay_msecs delay. More...
void | startDeferred (PIDateTime start_datetime)
| Start timer with interval() loop delay after start_datetime date and time. More...
void | startDeferred (double interval_ms, PIDateTime start_datetime)
| Start timer with interval_msecs loop delay after start_datetime date and time. More...
void | setData (void *data_)
| Set custom data.
void | setSlot (TimerEvent slot)
| Set timer tick function.
void * | data () const
| Returns common data passed to tick functions.
void | addDelimiter (int delim, TimerEvent slot=0)
| Add frequency delimiter delim with optional delimiter slot slot.
void | removeDelimiter (int delim)
| Remove all frequency delimiters delim.
void | removeDelimiter (TimerEvent slot)
| Remove all frequency delimiters with slot slot.
void | removeDelimiter (int delim, TimerEvent slot)
| Remove all frequency delimiters delim with slot slot.
Public Member Functions inherited from PIObject
| PIObject (const PIString &name=PIString())
| Contructs PIObject with name "name".
PIString | name () const
| Returns object name.
virtual const char * | className () const
| Returns object class name.
virtual const char * | parentClassName () const
| Returns parent object class name.
bool | debug () const
| Return if debug of this object is active.
void | setName (const PIString &name)
| Set object name.
void | setDebug (bool debug)
| Set object debug active.
const PIMap< PIString, PIVariant > & | properties () const
| Returns properties of the object.
int | propertiesCount () const
| Returns properties count of the object.
PIVariant | property (const PIString &name) const
| Returns property with name "name".
void | setProperty (const PIString &name, const PIVariant &value)
| Set property with name "name" to "value". If there is no such property in object it will be added.
bool | isPropertyExists (const PIString &name) const
| Returns if property with name "name" exists.

## Protected Member Functions
virtual void | tick (void *data_, int delimiter)
Protected Member Functions inherited from PIObject
PIObject * | emitter () const
| Returns PIObject* which has raised an event. This value is correct only in definition of some event handler.
virtual void | propertyChanged (const PIString &name)
| Virtual function executes after property with name "name" has been changed.
void | deleted ()
| Raise before object delete. More...

## Handlers
bool | start ()
| Start timer with interval() loop delay. More...
bool | start (double interval_ms_d)
| Start timer with msecs loop delay. More...
bool | restart ()
| Stop and start timer with interval() loop delay.
bool | stop (bool wait)
| Stop timer and wait for it finish if "wait".
void | clearDelimiters ()
| Remove all frequency delimiters.

## Events
void | tickEvent (void *data_, int delimiter)
| Raise on timer tick. More...

## Additional Inherited Members
Static Public Member Functions inherited from PIObject
static void | piDisconnect (PIObject *src, const PIString &sig)
| Disconnect object "src" from all connections with event name "sig".
static void | piDisconnect (PIObject *src)
| Disconnect object "src" from all connections, i.e. all connections where object "src" is emitter.
static PIObject * | findByName (const PIString &name)
| Returns PIObject* with name "name" or 0, if there is no object found.
Related Functions inherited from PIObject
#define | piCoutObj
| Macro used for conditional (piDebug and PIObject::debug()) output to PICout for subclasses of PIObject.
#define | PIOBJECT(name)
| you should use this macro after class declaration to use EVENT and EVENT_HANDLER and correct piCoutObj output
#define | PIOBJECT_SUBCLASS(name, parent)
| you should use this macro after class declaration to use EVENT and EVENT_HANDLER of parent class, and scopeList()
#define | EVENT_HANDLER0(ret, name) ret name()
| declare event handler "event" with name "name" and return type "ret", ret name()
#define | EVENT_HANDLER1(ret, name, type0, var0) ret name(type0 var0)
| declare event handler "event" with name "name" and return type "ret", ret name(type0 var0)
#define | EVENT_HANDLER2(ret, name, type0, var0, type1, var1) ret name(type0 var0, type1 var1)
| declare event handler "event" with name "name" and return type "ret", ret name(type0 var0, type1 var1)
#define | EVENT_HANDLER3(ret, name, type0, var0, type1, var1, type2, var2) ret name(type0 var0, type1 var1, type2 var2)
| declare event handler "event" with name "name" and return type "ret", ret name(type0 var0, type1 var1, type2 var2)
#define | EVENT_HANDLER4(ret, name, type0, var0, type1, var1, type2, var2, type3, var3) ret name(type0 var0, type1 var1, type2 var2, type3 var3)
| declare event handler "event" with name "name" and return type "ret", ret name(type0 var0, type1 var1, type2 var2, type3 var3)
#define | EVENT_HANDLER EVENT_HANDLER0
| EVENT_HANDLER is synonym of EVENT_HANDLER0.
#define | EVENT_VHANDLER0(ret, name) virtual ret name()
| declare virtual event handler "event" with name "name" and return type "ret", virtual ret name()
#define | EVENT_VHANDLER1(ret, name, type0, var0) virtual ret name(type0 var0)
| declare virtual event handler "event" with name "name" and return type "ret", virtual ret name(type0 var0)
#define | EVENT_VHANDLER2(ret, name, type0, var0, type1, var1) virtual ret name(type0 var0, type1 var1)
| declare virtual event handler "event" with name "name" and return type "ret", virtual ret name(type0 var0, type1 var1)
#define | EVENT_VHANDLER3(ret, name, type0, var0, type1, var1, type2, var2) virtual ret name(type0 var0, type1 var1, type2 var2)
| declare virtual event handler "event" with name "name" and return type "ret", virtual ret name(type0 var0, type1 var1, type2 var2)
#define | EVENT_VHANDLER4(ret, name, type0, var0, type1, var1, type2, var2, type3, var3) virtual ret name(type0 var0, type1 var1, type2 var2, type3 var3)
| declare virtual event handler "event" with name "name" and return type "ret", virtual ret name(type0 var0, type1 var1, type2 var2, type3 var3)
#define | EVENT_VHANDLER EVENT_VHANDLER0
| EVENT_VHANDLER is synonym of EVENT_VHANDLER0.
#define | EVENT0(name) void name();
| declare event "event" with name "name", void name();
#define | EVENT1(name, type0, var0) void name(type0 var0);
| declare event "event" with name "name", void name(type0 var0);
#define | EVENT2(name, type0, var0, type1, var1) void name(type0 var0, type1 var1);
| declare event "event" with name "name", void name(type0 var0, type1 var1);
#define | EVENT3(name, type0, var0, type1, var1, type2, var2) void name(type0 var0, type1 var1, type2 var2);
| declare event "event" with name "name", void name(type0 var0, type1 var1, type2 var2);
#define | EVENT4(name, type0, var0, type1, var1, type2, var2, type3, var3) void name(type0 var0, type1 var1, type2 var2, type3 var3);
| declare event "event" with name "name", void name(type0 var0, type1 var1, type2 var2, type3 var3);
#define | EVENT EVENT0
| EVENT is synonym of EVENT0.
#define | CONNECTU(src, event, dest, handler)
| connect event "event" from object "src" to event handler "handler". "Event" and "handler" must has equal argument lists.
#define | CONNECTU_QUEUED(src, event, dest, handler, performer)
| connect event "event" from object "src" to event handler "handler". Event handler will be executed by "performer". "Event" and "handler" must has equal argument lists.
#define | CONNECT0(ret, src, event, dest, handler)
| connect event "event" from object "src" to event handler "handler" with return type "ret" from object "dest" with check of event and handler exists
#define | CONNECT1(ret, type0, src, event, dest, handler)
| connect event "event" from object "src" to event handler "handler" with return type "ret" from object "dest" with check of event and handler exists
#define | CONNECT2(ret, type0, type1, src, event, dest, handler)
| connect event "event" from object "src" to event handler "handler" with return type "ret" from object "dest" with check of event and handler exists
#define | CONNECT3(ret, type0, type1, type2, src, event, dest, handler)
| connect event "event" from object "src" to event handler "handler" with return type "ret" from object "dest" with check of event and handler exists
#define | CONNECT4(ret, type0, type1, type2, type3, src, event, dest, handler)
| connect event "event" from object "src" to event handler "handler" with return type "ret" from object "dest" with check of event and handler exists
#define | CONNECT CONNECT0
| CONNECT is synonym of CONNECT0.
#define | WEAK_CONNECT0(ret, src, event, dest, handler)
| connect event "event" from object "src" to event handler "handler" with return type "ret" from object "dest" without check of event exists
#define | WEAK_CONNECT1(ret, type0, src, event, dest, handler)
| connect event "event" from object "src" to event handler "handler" with return type "ret" from object "dest" without check of event exists
#define | WEAK_CONNECT2(ret, type0, type1, src, event, dest, handler)
| connect event "event" from object "src" to event handler "handler" with return type "ret" from object "dest" without check of event exists
#define | WEAK_CONNECT3(ret, type0, type1, type2, src, event, dest, handler)
| connect event "event" from object "src" to event handler "handler" with return type "ret" from object "dest" without check of event exists
#define | WEAK_CONNECT4(ret, type0, type1, type2, type3, src, event, dest, handler)
| connect event "event" from object "src" to event handler "handler" with return type "ret" from object "dest" without check of event exists
#define | WEAK_CONNECT WEAK_CONNECT0
| WEAK_CONNECT is synonym of WEAK_CONNECT0.
#define | DISCONNECT0(ret, src, event, dest, handler)
| piDisconnect event "event" from object "src" from event handler "handler" with return type "ret" from object "dest"
#define | DISCONNECT1(ret, type0, src, event, dest, handler)
| piDisconnect event "event" from object "src" from event handler "handler" with return type "ret" from object "dest"
#define | DISCONNECT2(ret, type0, type1, src, event, dest, handler)
| piDisconnect event "event" from object "src" from event handler "handler" with return type "ret" from object "dest"
#define | DISCONNECT3(ret, type0, type1, type2, src, event, dest, handler)
| piDisconnect event "event" from object "src" from event handler "handler" with return type "ret" from object "dest"
#define | DISCONNECT4(ret, type0, type1, type2, type3, src, event, dest, handler)
| piDisconnect event "event" from object "src" from event handler "handler" with return type "ret" from object "dest"
#define | DISCONNECT DISCONNECT0
| DISCONNECT is synonym of DISCONNECT0.
#define | HANDLER(handler)
| Returns pointer to events handler "handler".

## Detailed Description

Timer.

# Synopsis

This class implements timer function. PIP timers supports 3 way to tick notify, frequency delimiters and time measurements.

# Notify variants

Notify variants:

- "slot" - static function with format void func(void * data, int delimiter);
- event - tickEvent();
- virtual function - tick().

All these variants are equivalent, use most applicable.

# Frequency delimiters

Frequency delimiter is an integer number and "slot" function. If "slot" function is null timer main "slot" will be used. Each delimiter numbers tick timer will be execute delimiters or timer main "slot" function with delimiter value = delimiter number. Example:

void tfunc(void * , int delim) {
piCout << "tick with delimiter" << delim;
};
void tfunc4(void * , int delim) {
piCout << "tick4 with delimiter" << delim;
};
int main() {
PITimer timer(tfunc);
timer.addDelimiter(2);
timer.addDelimiter(4, tfunc4);
timer.start(50);
piMSleep(200);
timer.stop();
timer.waitForFinish();
return 0;
};
/* Result:
tick with delimiter 1
tick with delimiter 1
tick with delimiter 2
tick with delimiter 1
tick with delimiter 1
tick with delimiter 2
tick4 with delimiter 4
*/

# Time measurements

PITimer can be used as time measurer. Function reset() set time mark to current system time, then functions double elapsed_*() returns time elapsed from this mark. These functions can returns nano-, micro-, milli- and seconds with suffixes "n", "u", "m" and "s" Example:

int main() {
PITimer timer;
piMSleep(100);
piCout << "elapsed" << timer.elapsed_m() << "ms";
piMSleep(100);
piCout << "elapsed" << timer.elapsed_m() << "ms";
timer.reset();
piMSleep(150);
piCout << "elapsed" << timer.elapsed_s() << "s";
return 0;
};
/* Result:
elapsed 100 ms
elapsed 200 ms
elapsed 0.15 s
*/

## Member Enumeration Documentation

## ◆ TimerImplementation

enum PITimer::TimerImplementation

Timer implementations.

Enumerator
Thread | Timer works in his own thread. Intervals are measured by the system time
ThreadRT | Using POSIX timer with SIGEV_THREAD notification. Attention Doesn`t support on Windows and Mac OS!
Pool | Using single TimerPool for all timers with this implementation. TimerPool works as Thread implementation and sequentially executes all timers. Attention Use this implementation with care!

## Member Function Documentation

## ◆ start() [1/2]

bool PITimer::start | ( |  | ) |
| inline

Start timer with interval() loop delay.

Start execution of timer functions with frequency = 1 / msecs Hz.

## ◆ start() [2/2]

bool PITimer::start | ( | double | msecs | ) |
| inline

Start timer with msecs loop delay.

Start execution of timer functions with frequency = 1. / msecs Hz. Instead of start(int msecs) function this variant allow start timer with frequencies more than 1 kHz

## ◆ startDeferred() [1/4]

void PITimer::startDeferred | ( | double | delay_ms | ) |
| inline

Start timer with interval() loop delay after delay_msecs delay.

Timer wait delay_msecs milliseconds and then normally starts with interval() loop delay.

## ◆ startDeferred() [2/4]

void PITimer::startDeferred | ( | double | interval_ms,
|  | double | delay_ms
| ) |  |
| inline

Start timer with interval_msecs loop delay after delay_msecs delay.

Timer wait delay_msecs milliseconds and then normally starts with interval_msecs loop delay.

## ◆ startDeferred() [3/4]

void PITimer::startDeferred | ( | PIDateTime | start_datetime | ) |
| inline

Start timer with interval() loop delay after start_datetime date and time.

Timer wait until start_datetime and then normally starts with interval() loop delay.

## ◆ startDeferred() [4/4]

void PITimer::startDeferred | ( | double | interval_ms,
|  | PIDateTime | start_datetime
| ) |  |
| inline

Start timer with interval_msecs loop delay after start_datetime date and time.

Timer wait until start_datetime and then normally starts with interval_msecs loop delay.

## ◆ tickEvent()

void PITimer::tickEvent | ( | void * | data,
|  | int | delimiter
| ) |  |

Raise on timer tick.

Data can be set with function setData(void * data) or from constructor. Delimiter is frequency delimiter, 1 for main loop.

## ◆ tick()

virtual void PITimer::tick | ( | void * | data_,
|  | int | delimiter
| ) |  |
| inline protected virtual

Virtual timer execution function, similar to "slot" or event void timeout(void * data, int delimiter). By default is empty.