/home/vlg/develop/libASSA/libassa/assa/Timer.h

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
//                             Timer.h
//------------------------------------------------------------------------------
//  Copyright (c) 1999,2005 by Vladislav Grinchenko
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Library General Public
//  License as published by the Free Software Foundation; either
//  version 2 of the License, or (at your option) any later version.
//------------------------------------------------------------------------------
//  Create: 09/27/1999
//------------------------------------------------------------------------------
#ifndef TIMER_H
#define TIMER_H

#if !defined(WIN32)
#   include <sys/select.h>
#endif

#include <sys/time.h>

#include "EventHandler.h"
#include "assa/TimeVal.h"

namespace ASSA {

class TimerQueue;       // forward declaration

class Timer 
{
public:
    Timer ();

    Timer (const EventHandler* eh_, 
           const TimeVal&      tm_,
           const TimeVal&      delta_,
           const std::string&  name_);

    Timer (const Timer& t_);

    ~Timer ();

    Timer& operator= (const Timer& t_);

    bool operator< (const Timer& t_) const;

    bool operator== (const Timer& t_) const;

    EventHandler* getHandler () const { return m_eh; }

    const TimeVal& getExpirationTime () const { return m_timer; }

    const TimeVal& getDeltaTime () const { return m_delta; }

    void rescheduleExpirationTime ();

    void dump (void);

    void set_id (const std::string& id_) { m_id = id_; }

    std::string get_id () const { return m_id; }

private:
    EventHandler* m_eh;

    TimeVal m_timer;

    TimeVal m_delta;

    std::string m_id;
};
//------------------------------------------------------------------------------
// Timer class inlines
//------------------------------------------------------------------------------

inline  
Timer::
Timer () 
    : m_eh (NULL), m_id ("<unknown>")
{
    trace("Timer::Timer");
}

inline
Timer::
Timer (const EventHandler* eh_, const TimeVal& tm_,
       const TimeVal& delta_, const std::string& name_)
    : m_eh ((EventHandler*) eh_), m_timer (tm_), m_delta (delta_), m_id (name_)
{
    trace("Timer::Timer(EH*, TV&)");
}

inline
Timer::
Timer (const Timer& t_)
    : m_eh (t_.m_eh), m_timer (t_.m_timer), 
      m_delta (t_.m_delta), m_id (t_.m_id)
{
    trace("Timer::Timer(Timer&)");
}

inline
Timer::
~Timer ()
{
    trace("Timer::~Timer");
}

inline Timer& 
Timer::
operator=(const Timer& t_)
{
    m_eh    = t_.m_eh;
    m_timer = t_.m_timer;
    m_delta = t_.m_delta;
    m_id    = t_.m_id;

    return *this;
}

inline bool 
Timer::
operator<(const Timer& t_) const
{
    return m_timer < t_.m_timer;
}

inline bool 
Timer::
operator==(const Timer& t_) const
{
    return m_timer == t_.m_timer;
}

inline void 
Timer::
rescheduleExpirationTime ()
{
    TimeVal now (TimeVal::gettimeofday ());
    m_timer = now + m_delta;
}

inline void
Timer::
dump (void)
{
    DL((REACT,"Timer %s (EH=%s) expires at %s (delta=%s)\n",
        get_id ().c_str (),
        m_eh->get_id ().c_str (), 
        m_timer.fmtString ().c_str(),
        m_delta.fmt_mm_ss_mls ().c_str()));
}

struct TimerCompare 
{
    bool operator() (const Timer* t1_, const Timer* t2_) const 
        {
            return (*t1_ < *t2_);
        }
};

} // end namespace ASSA

#endif /* TIMER_H */  

---