From 6e1024262b48b57b771331b8c19e988e43627bd7 Mon Sep 17 00:00:00 2001
From: Benny Prijono <bennylp@teluu.com>
Date: Wed, 9 Nov 2005 15:37:19 +0000
Subject: Rework pjlib++

git-svn-id: http://svn.pjsip.org/repos/pjproject/main@36 74dad513-b988-da41-8d7b-12977e46ad98
---
 pjlib/include/pj++/timer.hpp | 161 +++++++++++++++++++++++++++++++------------
 1 file changed, 117 insertions(+), 44 deletions(-)

(limited to 'pjlib/include/pj++/timer.hpp')

diff --git a/pjlib/include/pj++/timer.hpp b/pjlib/include/pj++/timer.hpp
index 8357a198..b1070421 100644
--- a/pjlib/include/pj++/timer.hpp
+++ b/pjlib/include/pj++/timer.hpp
@@ -1,101 +1,174 @@
 /* $Id$
- *
  */
 #ifndef __PJPP_TIMER_H__
 #define __PJPP_TIMER_H__
 
 #include <pj/timer.h>
 #include <pj++/types.hpp>
-
-class PJ_Timer_Heap;
-
-class PJ_Timer_Entry : private pj_timer_entry
+#include <pj/assert.h>
+#include <pj++/lock.hpp>
+
+class Pj_Timer_Heap;
+
+//////////////////////////////////////////////////////////////////////////////
+// Timer entry.
+//
+// How to use:
+//  Derive class from Pj_Timer_Entry and override on_timeout().
+//  Scheduler timer in Pj_Timer_Heap.
+//
+class Pj_Timer_Entry : public Pj_Object
 {
-    friend class PJ_Timer_Heap;
+    friend class Pj_Timer_Heap;
 
 public:
-    static void timer_heap_callback(pj_timer_heap_t *, pj_timer_entry *);
+    //
+    // Default constructor.
+    //
+    Pj_Timer_Entry() 
+    { 
+        entry_.user_data = this;
+        entry_.cb = &timer_heap_callback; 
+    }
 
-    PJ_Timer_Entry() { cb = &timer_heap_callback; }
-    PJ_Timer_Entry(int arg_id, void *arg_user_data)
+    //
+    // Destructor, do nothing.
+    //
+    ~Pj_Timer_Entry()
     {
-	cb = &timer_heap_callback; 
-	init(arg_id, arg_user_data);
     }
 
-    virtual void on_timeout() = 0;
+    //
+    // Override this to get the timeout notification.
+    //
+    virtual void on_timeout(int id) = 0;
+
+private:
+    pj_timer_entry entry_;
 
-    void init(int arg_id, void *arg_user_data)
+    static void timer_heap_callback(pj_timer_heap_t *th, pj_timer_entry *e)
     {
-	id = arg_id;
-	user_data = arg_user_data;
+        Pj_Timer_Entry *entry = (Pj_Timer_Entry*) e->user_data;
+        entry->on_timeout(e->id);
     }
 
-    int get_id() const
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// Timer heap.
+//
+class Pj_Timer_Heap : public Pj_Object
+{
+public:
+    //
+    // Default constructor.
+    //
+    Pj_Timer_Heap() 
+        : ht_(NULL) 
     {
-	return id;
     }
 
-    void set_id(int arg_id)
+    //
+    // Construct timer heap.
+    //
+    Pj_Timer_Heap(Pj_Pool *pool, pj_size_t initial_count)
+        : ht_(NULL)
     {
-	id = arg_id;
+        create(pool, initial_count);
     }
 
-    void set_user_data(void *arg_user_data)
+    //
+    // Destructor.
+    //
+    ~Pj_Timer_Heap()
     {
-	user_data = arg_user_data;
+        destroy();
     }
 
-    void *get_user_data() const
+    //
+    // Create
+    // 
+    pj_status_t create(Pj_Pool *pool, pj_size_t initial_count)
     {
-	return user_data;
+        destroy();
+	return pj_timer_heap_create(pool->pool_(), initial_count, &ht_);
     }
 
-    const PJ_Time_Val &get_timeout() const
+    //
+    // Destroy
+    //
+    void destroy()
     {
-	pj_assert(sizeof(PJ_Time_Val) == sizeof(pj_time_val));
-	return (PJ_Time_Val&)_timer_value;
+        if (ht_) {
+            pj_timer_heap_destroy(ht_);
+            ht_ = NULL;
+        }
     }
-};
 
-class PJ_Timer_Heap
-{
-public:
-    PJ_Timer_Heap() {}
+    //
+    // Get pjlib compatible timer heap object.
+    //
+    pj_timer_heap_t *get_timer_heap()
+    {
+	return ht_;
+    }
 
-    bool create(PJ_Pool *pool, pj_size_t initial_count, 
-		unsigned flag = PJ_TIMER_HEAP_SYNCHRONIZE)
+    //
+    // Set the lock object.
+    //
+    void set_lock( Pj_Lock *lock, bool auto_delete )
     {
-	ht_ = pj_timer_heap_create(pool->pool_(), initial_count, flag);
-	return ht_ != NULL;
+        pj_timer_heap_set_lock( ht_, lock->pj_lock_t_(), auto_delete);
     }
 
-    pj_timer_heap_t *get_timer_heap()
+    //
+    // Set maximum number of timed out entries to be processed per poll.
+    //
+    unsigned set_max_timed_out_per_poll(unsigned count)
     {
-	return ht_;
+        return pj_timer_heap_set_max_timed_out_per_poll(ht_, count);
     }
 
-    bool schedule( PJ_Timer_Entry *ent, const PJ_Time_Val &delay)
+    //
+    // Schedule a timer.
+    //
+    bool schedule( Pj_Timer_Entry *ent, const Pj_Time_Val &delay,
+                   int id)
     {
-	return pj_timer_heap_schedule(ht_, ent, &delay) == 0;
+        ent->entry_.id = id;
+	return pj_timer_heap_schedule(ht_, &ent->entry_, &delay) == 0;
     }
 
-    bool cancel(PJ_Timer_Entry *ent)
+    //
+    // Cancel a timer.
+    //
+    bool cancel(Pj_Timer_Entry *ent)
     {
-	return pj_timer_heap_cancel(ht_, ent) == 1;
+	return pj_timer_heap_cancel(ht_, &ent->entry_) == 1;
     }
 
+    //
+    // Get current number of timers
+    //
     pj_size_t count()
     {
 	return pj_timer_heap_count(ht_);
     }
 
-    void earliest_time(PJ_Time_Val *t)
+    //
+    // Get the earliest time.
+    // Return false if no timer is found.
+    //
+    bool earliest_time(Pj_Time_Val *t)
     {
-	pj_timer_heap_earliest_time(ht_, t);
+	return pj_timer_heap_earliest_time(ht_, t) == PJ_SUCCESS;
     }
 
-    int poll(PJ_Time_Val *next_delay = NULL)
+    //
+    // Poll the timer.
+    // Return number of timed out entries has been called.
+    //
+    unsigned poll(Pj_Time_Val *next_delay = NULL)
     {
 	return pj_timer_heap_poll(ht_, next_delay);
     }
-- 
cgit v1.2.3