NAME

       zmq_timers - helper functions for cross-platform timers callbacks

SYNOPSIS

       typedef void(zmq_timer_fn) (int timer_id, void *arg);

       void *zmq_timers_new (void);

       int zmq_timers_destroy (void *timers_p);*

       int zmq_timers_add (void *timers, size_t interval, zmq_timer_fn handler, void *arg);

       int zmq_timers_cancel (void *timers, int timer_id);

       int zmq_timers_set_interval (void *timers, int timer_id, size_t interval);

       int zmq_timers_reset (void *timers, int timer_id);

       long zmq_timers_timeout (void *timers);

       int zmq_timers_execute (void *timers);

DESCRIPTION

       The zmq_timers*_ functions provide cross-platform access to timers callbacks. Once a timer has been
       registered, it will repeat at the specified interval until it gets manually cancelled. To run the
       callbacks, zmq_timers_execute must be ran.

       zmq_timers_new and zmq_timers_destroy manage the lifetime of a timer instance. zmq_timers_new creates and
       returns a new timer instance, while zmq_timers_destroy destroys it. A pointer to a valid timer must be
       passed as the timers_p argument of zmq_timers_destroy. In particular, zmq_timers_destroy may not be
       called multiple times for the same timer instance. zmq_timers_destroy sets the passed pointer to NULL in
       case of a successful execution.

       zmq_timers_add and zmq_timers_cancel manage the timers registered.

       zmq_timers_add registers a new timer with a given instance. timers must point to a valid timers object.
       The interval parameter specifies the expiration of the timer in milliseconds. handler and arg specify the
       callback that will be invoked on expiration and the optional parameter that will be passed through. The
       callback must be a valid function implementing the zmq_timer_fn prototype. An ID will be returned that
       can be used to modify or cancel the timer.

       zmq_timers_cancel will cancel the timer associated with timer_id from the instance timers.

       zmq_timers_set_interval will set the expiration of the timer associated with timer_id from the instance
       timers to interval milliseconds into the future.

       zmq_timers_reset will restart the timer associated with timer_id from the instance timers.

       zmq_timers_timeout will return the time left in milliseconds until the next timer registered with timers
       expires.

       zmq_timers_execute will run callbacks of all expired timers from the instance timers.

THREAD SAFETY

       Like most other 0MQ objects, timers are not thread-safe. All operations must be called from the same
       thread. Otherwise, behaviour is undefined.

RETURN VALUE

       zmq_timers_new always returns a valid pointer to a poller.

       All functions that return an int, return -1 in case of a failure. In that case, zmq_errno() can be used
       to query the type of the error as described below.

       zmq_timers_timeout returns the time left in milliseconds until the next timer registered with timers
       expires, or -1 if there are no timers left.

       All other functions return 0 in case of a successful execution.

ERRORS

       On zmq_timers_destroy, zmq_poller_cancel, zmq_timers_set_interval, zmq_timers_reset, zmq_timers_timeout_,
       and zmq_timers_execute: EFAULT:: timers did not point to a valid timer. Note that passing an invalid
       pointer (e.g. pointer to deallocated memory) may cause undefined behaviour (e.g. an access violation).

       On zmq_timers_add: EFAULT:: timers did not point to a valid timer or handler did not point to a valid
       function.

       On zmq_poller_cancel, zmq_timers_set_interval and zmq_timers_timeout_: EINVAL:: timer_id did not exist or
       was already cancelled.

EXAMPLE

       Add one timer with a simple callback that changes a boolean..

               void handler (int timer_id_, void *arg_)
               {
                   (void) timer_id_; //  Stop 'unused' compiler warnings
                   *((bool *) arg_) = true;
               }

               ...

               void *timers = zmq_timers_new ();
               assert (timers);

               bool timer_invoked = false;

               const unsigned long full_timeout = 100;

               int timer_id =
                 zmq_timers_add (timers, full_timeout, handler, &timer_invoked);
               assert (timer_id);

               //  Timer should not have been invoked yet
               int rc = zmq_timers_execute (timers);
               assert (rc == 0);

               //  Wait half the time and check again
               long timeout = zmq_timers_timeout (timers);
               assert (rc != -1);
               msleep (timeout / 2);
               rc = zmq_timers_execute (timers);
               assert (rc == 0);

               // Wait until the end
               rc = msleep (zmq_timers_timeout (timers));
               assert (rc == 0);
               assert (timer_invoked);

               rc = zmq_timers_destroy (&timers);
               assert (rc == 0);

SEE ALSO

       zmq(7)

AUTHORS

       This page was written by the 0MQ community. To make a change please read the 0MQ Contribution Policy at
       http://www.zeromq.org/docs:contributing.