timer.h

Go to the documentation of this file.

/* $Id$ */
/* 
 * 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__ */