ucommon/timers.h

Go to the documentation of this file.

// Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
//
// This file is part of GNU uCommon C++.
//
// GNU uCommon C++ is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published 
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GNU uCommon C++ 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.

#ifndef _UCOMMON_TIMERS_H_
#define _UCOMMON_TIMERS_H_

#ifndef _UCOMMON_LINKED_H_
#include <ucommon/linked.h>
#endif

#ifndef _MSWINDOWS_
#include <unistd.h>
#include <sys/time.h>
#endif

#include <time.h>

NAMESPACE_UCOMMON

class __EXPORT Timer
{
private:
    friend class Conditional;
    friend class Semaphore;
    friend class Event;

#if _POSIX_TIMERS > 0
    timespec timer;
#else
    timeval timer;
#endif
    bool updated;

public:
    static const timeout_t inf; 
    static const time_t reset;  
    Timer();

    Timer(timeout_t offset);

    Timer(time_t offset);

    Timer(const Timer& copy);

    bool isExpired(void);

    bool isUpdated(void);

    void set(timeout_t expire);

    void set(time_t expire);

    void set(void);

    void clear(void);   

    timeout_t get(void) const;

    inline timeout_t operator*() const
        {return get();};

    bool operator!() const;

    operator bool() const;

    Timer& operator=(time_t expire);

    Timer& operator=(timeout_t expire);

    Timer& operator+=(time_t expire);

    Timer& operator+=(timeout_t expire);

    Timer& operator-=(time_t expire);

    Timer& operator-=(timeout_t expire);

    timeout_t operator-(const Timer& timer);

    bool operator==(const Timer& timer);

    bool operator!=(const Timer& timer);

    bool operator<(const Timer& timer);

    bool operator<=(const Timer& timer);

    bool operator>(const Timer& timer);

    bool operator>=(const Timer& timer);

    static void sync(Timer &timer);
};
    
class __EXPORT TimerQueue : public OrderedIndex
{
public:
    class __EXPORT event : protected Timer, public LinkedList
    {
    protected:
        friend class TimerQueue;

        event(timeout_t expire);

        event(TimerQueue *queue, timeout_t expire);

        virtual void expired(void) = 0;

        virtual timeout_t timeout(void);

    public:
        virtual ~event();

        void attach(TimerQueue *queue);

        void detach(void);

        void arm(timeout_t timeout);

        void disarm(void);

        inline bool isExpired(void)
            {return Timer::isExpired();};

        inline timeout_t get(void) const
            {return Timer::get();};

        void update(void);

        inline TimerQueue *getQueue(void)
            {return static_cast<TimerQueue*>(root);};
    };  

protected:
    friend class event;

    virtual void modify(void) = 0;

    virtual void update(void) = 0;

public:
    TimerQueue();

    virtual ~TimerQueue();

    void operator+=(event &timer);

    void operator-=(event &timer);

    timeout_t expire();
};  

typedef TimerQueue::event TQEvent;

typedef Timer timer_t;

END_NAMESPACE

extern "C" {
#if defined(WIN32)
    __EXPORT int gettimeofday(struct timeval *tv, void *tz);
#endif
}

#endif

---