timer.h

Go to the documentation of this file.

/* 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 */
 
#ifndef __PJ_TIMER_H__
#define __PJ_TIMER_H__
 
#include <pj/types.h>
#include <pj/lock.h>
 
#if PJ_TIMER_USE_LINKED_LIST
#  include <pj/list.h>
#endif
 
PJ_BEGIN_DECL
 
typedef int pj_timer_id_t;
 
struct pj_timer_entry;
 
typedef void pj_timer_heap_callback(pj_timer_heap_t *timer_heap,
                                    struct pj_timer_entry *entry);
 
 
typedef struct pj_timer_entry
{
#if !PJ_TIMER_USE_COPY && PJ_TIMER_USE_LINKED_LIST
    PJ_DECL_LIST_MEMBER(struct pj_timer_entry);
#endif
 
    void *user_data;
 
    int id;
 
    pj_timer_heap_callback *cb;
 
    pj_timer_id_t _timer_id;
 
#if !PJ_TIMER_USE_COPY
    pj_time_val _timer_value;
 
    pj_grp_lock_t *_grp_lock;
 
#if PJ_TIMER_DEBUG
    const char  *src_file;
    int          src_line;
#endif
 
#endif
} pj_timer_entry;
 
 
PJ_DECL(pj_size_t) pj_timer_heap_mem_size(pj_size_t count);
 
PJ_DECL(pj_status_t) pj_timer_heap_create( pj_pool_t *pool,
                                           pj_size_t count,
                                           pj_timer_heap_t **ht);
 
PJ_DECL(void) pj_timer_heap_destroy( pj_timer_heap_t *ht );
 
 
PJ_DECL(void) pj_timer_heap_set_lock( pj_timer_heap_t *ht,
                                      pj_lock_t *lock,
                                      pj_bool_t auto_del );
 
PJ_DECL(unsigned) pj_timer_heap_set_max_timed_out_per_poll(pj_timer_heap_t *ht,
                                                           unsigned count );
 
PJ_DECL(pj_timer_entry*) pj_timer_entry_init( pj_timer_entry *entry,
                                              int id,
                                              void *user_data,
                                              pj_timer_heap_callback *cb );
 
PJ_DECL(pj_bool_t) pj_timer_entry_running( pj_timer_entry *entry );
 
#if PJ_TIMER_DEBUG
#  define pj_timer_heap_schedule(ht,e,d) \
                        pj_timer_heap_schedule_dbg(ht,e,d,__FILE__,__LINE__)
 
  PJ_DECL(pj_status_t) pj_timer_heap_schedule_dbg( pj_timer_heap_t *ht,
                                                   pj_timer_entry *entry,
                                                   const pj_time_val *delay,
                                                   const char *src_file,
                                                   int src_line);
#else
PJ_DECL(pj_status_t) pj_timer_heap_schedule( pj_timer_heap_t *ht,
                                             pj_timer_entry *entry, 
                                             const pj_time_val *delay);
#endif  /* PJ_TIMER_DEBUG */
 
#if PJ_TIMER_DEBUG
#  define pj_timer_heap_schedule_w_grp_lock(ht,e,d,id,g) \
        pj_timer_heap_schedule_w_grp_lock_dbg(ht,e,d,id,g,__FILE__,__LINE__)
 
  PJ_DECL(pj_status_t) pj_timer_heap_schedule_w_grp_lock_dbg(
                                                   pj_timer_heap_t *ht,
                                                   pj_timer_entry *entry,
                                                   const pj_time_val *delay,
                                                   int id_val,
                                                   pj_grp_lock_t *grp_lock,
                                                   const char *src_file,
                                                   int src_line);
#else
PJ_DECL(pj_status_t) pj_timer_heap_schedule_w_grp_lock(
                                                    pj_timer_heap_t *ht,
                                                    pj_timer_entry *entry,
                                                    const pj_time_val *delay,
                                                    int id_val,
                                                    pj_grp_lock_t *grp_lock);
#endif  /* PJ_TIMER_DEBUG */
 
 
PJ_DECL(int) pj_timer_heap_cancel( pj_timer_heap_t *ht,
                                   pj_timer_entry *entry);
 
PJ_DECL(int) pj_timer_heap_cancel_if_active(pj_timer_heap_t *ht,
                                            pj_timer_entry *entry,
                                            int id_val);
 
PJ_DECL(pj_size_t) pj_timer_heap_count( pj_timer_heap_t *ht );
 
PJ_DECL(pj_status_t) pj_timer_heap_earliest_time( pj_timer_heap_t *ht, 
                                                  pj_time_val *timeval);
 
PJ_DECL(unsigned) pj_timer_heap_poll( pj_timer_heap_t *ht, 
                                      pj_time_val *next_delay);
 
#if PJ_TIMER_DEBUG
PJ_DECL(void) pj_timer_heap_dump(pj_timer_heap_t *ht);
#endif
 
PJ_END_DECL
 
#endif  /* __PJ_TIMER_H__ */