timer.hh

Go to the documentation of this file.

// -*- c-basic-offset: 4; related-file-name: "../../lib/timer.cc" -*-
#ifndef CLICK_TIMER_HH
#define CLICK_TIMER_HH
#include <click/sync.hh>
#include <click/glue.hh>
#include <click/element.hh>
#include <click/timestamp.hh>
CLICK_DECLS
class RouterThread;
 
typedef void (*TimerCallback)(Timer *timer, void *user_data);
typedef TimerCallback TimerHook CLICK_DEPRECATED;
 
class Timer { public:
 
    Timer();
 
    struct do_nothing_t {
    };
 
    Timer(const do_nothing_t &unused);
 
    Timer(TimerCallback f, void *user_data);
 
    Timer(Element *element);
 
    Timer(Task *task);
 
    Timer(const Timer &x);
 
    inline ~Timer() {
        if (scheduled())
            unschedule();
    }
 
 
    inline void assign() {
        _hook.callback = do_nothing_hook;
        _thunk = (void *) 1;
    }
 
    inline void assign(const do_nothing_t &unused) {
        (void) unused;
        assign();
    }
 
    inline void assign(TimerCallback f, void *user_data) {
        _hook.callback = f;
        _thunk = user_data;
    }
 
    void assign(Element *element) {
        _hook.callback = element_hook;
        _thunk = element;
    }
 
    void assign(Task *task) {
        _hook.callback = task_hook;
        _thunk = task;
    }
 
 
    inline bool initialized() const {
        return _owner != 0;
    }
 
    inline bool scheduled() const {
        return _schedpos1 != 0;
    }
 
 
    inline const Timestamp &expiry_steady() const {
        return _expiry_s;
    }
 
    inline Timestamp expiry() const {
        if (_expiry_s)
            return _expiry_s + Timestamp::recent() - Timestamp::recent_steady();
        else
            return _expiry_s;
    }
 
    inline Router *router() const {
        return _owner->router();
    }
 
    inline Element *element() const {
        return _owner;
    }
 
    inline RouterThread *thread() const {
        return _thread;
    }
 
    int home_thread_id() const;
 
    void move_thread(int tid);
 
    void initialize(Element *owner, bool quiet = false);
 
    void initialize(Router *router);
 
 
    void schedule_at_steady(const Timestamp &when_steady);
 
    void reschedule_at_steady(const Timestamp &when_steady);
 
    inline void schedule_at(const Timestamp &when);
 
    inline void reschedule_at(const Timestamp &when);
 
    inline void schedule_now() {
        schedule_at_steady(Timestamp::recent_steady());
    }
 
    void schedule_after(const Timestamp &delta);
 
    inline void schedule_after_sec(uint32_t delta_sec) {
        schedule_after(Timestamp(delta_sec, 0));
    }
 
    inline void schedule_after_msec(uint32_t delta_msec) {
        schedule_after(Timestamp::make_msec(delta_msec));
    }
 
    inline void reschedule_after(const Timestamp &delta) {
        schedule_at_steady(_expiry_s + delta);
    }
 
    inline void reschedule_after_sec(uint32_t delta_sec) {
        schedule_at_steady(Timestamp(_expiry_s.sec() + delta_sec, _expiry_s.subsec()));
    }
 
    inline void reschedule_after_msec(uint32_t delta_msec) {
        schedule_at_steady(_expiry_s + Timestamp::make_msec(delta_msec));
    }
 
 
    void unschedule();
 
    inline void clear() {
        unschedule();
        _expiry_s = Timestamp();
    }
 
 
    static inline Timestamp adjustment() {
#if TIMESTAMP_WARPABLE
        if (Timestamp::warp_jumping())
            return Timestamp();
#endif
        return Timestamp::make_usec(500);
    }
 
 
    inline void schedule_after_s(uint32_t delta_sec) CLICK_DEPRECATED;
 
    inline void schedule_after_ms(uint32_t delta_sec) CLICK_DEPRECATED;
 
    inline void reschedule_after_s(uint32_t delta_sec) CLICK_DEPRECATED;
 
    inline void reschedule_after_ms(uint32_t delta_sec) CLICK_DEPRECATED;
 
    enum { behind_sec = 1 };
 
  private:
 
    int _schedpos1;
    Timestamp _expiry_s;
    union {
        TimerCallback callback;
    } _hook;
    void *_thunk;
    Element *_owner;
    RouterThread *_thread;
 
    Timer &operator=(const Timer &x);
 
    static void do_nothing_hook(Timer *t, void *user_data);
    static void element_hook(Timer *t, void *user_data);
    static void task_hook(Timer *t, void *user_data);
 
    friend class TimerSet;
 
};
 
inline void
Timer::schedule_at(const Timestamp &when)
{
    schedule_at_steady(when + Timestamp::recent_steady() - Timestamp::recent());
}
 
inline void
Timer::reschedule_at(const Timestamp &when)
{
    schedule_at(when);
}
 
inline void
Timer::schedule_after_s(uint32_t delta_sec)
{
    schedule_after_sec(delta_sec);
}
 
inline void
Timer::schedule_after_ms(uint32_t delta_msec)
{
    schedule_after_msec(delta_msec);
}
 
inline void
Timer::reschedule_after_s(uint32_t delta_sec)
{
    reschedule_after_sec(delta_sec);
}
 
inline void
Timer::reschedule_after_ms(uint32_t delta_msec)
{
    reschedule_after_msec(delta_msec);
}
 
CLICK_ENDDECLS
#endif