/Users/baford/proj/netsteria/sst/lib/timer.h

// Timing and timers for SST protocol use.
#ifndef SST_TIMER_H
#define SST_TIMER_H

#include <QObject>

class QDateTime;
class QTimerEvent;


namespace SST {

class XdrStream;
class Timer;
class TimerEngine;
class TimerHostState;


class Time
{
        friend class Timer;

public:
        qint64 usecs;           


        inline Time() { }
        inline Time(qint64 usecs) : usecs(usecs) { }
        inline Time(const Time &other) : usecs(other.usecs) { }

        inline bool operator==(const Time &other) const
                { return usecs == other.usecs; }
        inline bool operator!=(const Time &other) const
                { return usecs != other.usecs; }
        inline bool operator<(const Time &other) const
                { return usecs < other.usecs; }
        inline bool operator>(const Time &other) const
                { return usecs > other.usecs; }
        inline bool operator<=(const Time &other) const
                { return usecs <= other.usecs; }
        inline bool operator>=(const Time &other) const
                { return usecs >= other.usecs; }


        inline Time since(const Time &other) const
                { return Time(qMax(usecs - other.usecs, (qint64)0)); }


        QString toString() const;

        static Time fromString(const QString &str);


        QDateTime toQDateTime() const;

        static Time fromQDateTime(const QDateTime &qdt);


        // XX actually need these?
        static Time decode(const QByteArray &data);
        QByteArray encode() const;
};

XdrStream &operator>>(XdrStream &rs, Time &t);
XdrStream &operator<<(XdrStream &ws, const Time &t);


class TimerEngine : public QObject
{
        friend class Timer;

        Q_OBJECT

protected:
        TimerEngine(Timer *t);

        Timer *timer() const { return (Timer*)parent(); }


        virtual void start(quint64 usecs) = 0;

        virtual void stop() = 0;


        void timeout();
};


class Timer : public QObject
{
        friend class TimerEngine;

        Q_OBJECT

        TimerEngine *te;
        qint64 iv;
        qint64 fail;
        bool act;

public:

        static const qint64 retryMin = 500*1000;

        static const qint64 retryMax = 60*1000*1000;

        static const qint64 failMax = 20*1000*1000;


        static qint64 backoff(qint64 period, qint64 maxperiod = failMax)
                { return qMin(period * 3 / 2, maxperiod); }


        Timer(TimerHostState *host, QObject *parent = NULL);

        inline bool isActive() const { return act; }

        /* Obtain the timer's current interval.
         * @return the current interval in microseconds */
        inline qint64 interval() const { return iv; }


        inline void start(qint64 initperiod = retryMin,
                          qint64 failperiod = failMax)
                { fail = failperiod; act = true; te->start(iv = initperiod); }

        inline void stop()
                { te->stop(); act = false; }

        inline void restart()
                { act = true; te->start(iv = backoff(iv)); }

        inline bool failed()
                { return fail <= 0; }


signals:
        void timeout(bool failed);
};


class DefaultTimerEngine : public TimerEngine
{
        friend class TimerHostState;

        Q_OBJECT
        int timerid;

        inline DefaultTimerEngine(Timer *t) : TimerEngine(t), timerid(0) { }
        ~DefaultTimerEngine();

        virtual void start(quint64 usecs);
        virtual void stop();

        virtual void timerEvent(QTimerEvent *);
};


class TimerHostState : public QObject
{
        Q_OBJECT

public:
        virtual Time currentTime();


        virtual TimerEngine *newTimerEngine(Timer *timer);
};

} // namespace SST


#endif  // SST_TIMER_H

---