include/click/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 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

---