timer.h

Go to the documentation of this file.

/*
 * timer.h
 *
 * Real time down counting time interval class.
 *
 * Portable Windows Library
 *
 * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
 * All Rights Reserved.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 29407 $
 * $Author: rjongbloed $
 * $Date: 2013-04-01 21:10:26 +1100 (Mon, 01 Apr 2013) $
 */

#ifndef PTLIB_TIMER_H
#define PTLIB_TIMER_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif


#include <ptlib/notifier.h>
#include <ptclib/threadpool.h>


// To avoid ambiguous operator error we need a one for every integer variant
#define PTIMER_OPERATORS(cls) \
    cls & operator=( int16_t rhs)              { this->SetInterval(rhs); return *this; } \
    cls & operator=(uint16_t rhs)              { this->SetInterval(rhs); return *this; } \
    cls & operator=( int32_t rhs)              { this->SetInterval(rhs); return *this; } \
    cls & operator=(uint32_t rhs)              { this->SetInterval(rhs); return *this; } \
    cls & operator=( int64_t rhs)              { this->SetInterval(rhs); return *this; } \
    cls & operator=(uint64_t rhs)              { this->SetInterval(rhs); return *this; } \
    cls & operator=(const PTimeInterval & rhs) { this->SetInterval(rhs.GetMilliSeconds()); return *this; } \


class PSimpleTimer : public PTimeInterval
{
  PCLASSINFO(PSimpleTimer, PTimeInterval);

  public:
    PSimpleTimer(
      long milliseconds = 0,  
      int seconds = 0,        
      int minutes = 0,        
      int hours = 0,          
      int days = 0            
    );
    PSimpleTimer(
      const PTimeInterval & time    
    );
    PSimpleTimer(
      const PSimpleTimer & timer    
    );

    PSimpleTimer & operator=(
      DWORD milliseconds            
    );
    PSimpleTimer & operator=(
      const PTimeInterval & time    
    );
    PSimpleTimer & operator=(
      const PSimpleTimer & timer          
    );

    virtual void SetInterval(
      PInt64 milliseconds = 0,  
      long seconds = 0,         
      long minutes = 0,         
      long hours = 0,           
      int days = 0              
    );

    void Stop();

    PTimeInterval GetElapsed() const;

    PTimeInterval GetRemaining() const;

    bool IsRunning() const;

    bool HasExpired() const;

    operator bool() const;

  protected:
    PTimeInterval m_startTick;
};


class PTimer : public PTimeInterval
{
  PCLASSINFO(PTimer, PTimeInterval);

  public:
    typedef unsigned IDType;

    PTimer(
      long milliseconds = 0,  
      int seconds = 0,        
      int minutes = 0,        
      int hours = 0,          
      int days = 0            
    );
    PTimer(
      const PTimeInterval & time    
    );
    PTimer(
      const PTimer & timer    
    );

    PTimer & operator=(
      const PTimer & timer          
    ) { SetInterval(timer.GetMilliSeconds()); return *this; }

    PTIMER_OPERATORS(PTimer);

    virtual ~PTimer();

    virtual void SetInterval(
      PInt64 milliseconds = 0,  
      long seconds = 0,         
      long minutes = 0,         
      long hours = 0,           
      int days = 0              
    );

    void RunContinuous(
      const PTimeInterval & time    // New time interval for timer.
    );

    void Stop(
      bool wait = true  
    );

    PBoolean IsRunning() const;

    void Pause();

    void Resume();

    PBoolean IsPaused() const;

    void Reset();

    const PTimeInterval & GetResetTime() const;

    virtual void OnTimeout();

    const PNotifier & GetNotifier() const;

    void SetNotifier(
      const PNotifier & func  // New notifier function for the timer.
    );

    static PTimeInterval Tick();

    static unsigned Resolution();

    PInt64 GetMilliSeconds() const;

    PInt64 GetAbsoluteTime() const { return m_absoluteTime; }

    // Internal functions.
    IDType GetTimerId() const { return m_timerId; }
    PAtomicInteger::IntegerType GetNextSerialNumber() { return ++m_serialNumber; }

  private:
    void Construct();

    /* Start or restart the timer from the <code>resetTime</code> variable.
       This is an internal function.
     */
    void StartRunning(
      PBoolean once   // Flag for one shot or continuous.
    );

    /* Process the timer decrementing it by the delta amount and calling the
       <code>OnTimeout()</code> when zero. This is used internally by the
       <code>PTimerList::Process()</code> function.
     */
    void Process(
      PInt64 now             // time consider as "now"
    );

    // Member variables

    // Callback function for expired timers.
    PNotifier m_callback;

    // The time to reset a timer to when RunContinuous() is called.
    PTimeInterval m_resetTime;

    // Timer operates once then stops.
    PBoolean m_oneshot;

    // Timer state.
    enum TimerState { Stopped, Running, Paused, InTimeout } m_state;

    friend class PTimerList;              // needed for Process
    class PTimerList * m_timerList;  

    IDType m_timerId;
    PAtomicInteger m_serialNumber;
    PInt64 m_absoluteTime;

// Include platform dependent part of class
#ifdef _WIN32
#include "msos/ptlib/timer.h"
#else
#include "unix/ptlib/timer.h"
#endif
};


template <
  class Work_T,
  class Pool_T = PQueuedThreadPool<Work_T>
>
class PPoolTimer : public PTimer
{
    PCLASSINFO(PPoolTimer, PTimer);
  protected:
    Pool_T & m_pool;
  public:
    PPoolTimer(Pool_T & pool)
      : m_pool(pool)
    {
    }

    virtual void OnTimeout()
    {
      Work_T * work = CreateWork();
      if (work != NULL)
        m_pool.AddWork(work, GetGroup(*work));
    }

    virtual Work_T * CreateWork() = 0;
    virtual const char * GetGroup(const Work_T & /*work*/) const { return NULL; }

    PTIMER_OPERATORS(PPoolTimer);
};


template <
  class Work_T,
  class Base_T = Work_T,
  class Pool_T = PQueuedThreadPool<Base_T>
>
class PPoolTimerArg0 : public PPoolTimer<Base_T, Pool_T>
{
    typedef PPoolTimer<Base_T, Pool_T> BaseClass;
    PCLASSINFO(PPoolTimerArg0, BaseClass);
  public:
    PPoolTimerArg0(Pool_T & pool)
      : BaseClass(pool)
    {
    }

    virtual Work_T * CreateWork() { return new Work_T(); }

    PTIMER_OPERATORS(PPoolTimerArg0);
};


template <
  class Work_T,
  typename Arg1,
  class Base_T = Work_T,
  class Pool_T = PQueuedThreadPool<Base_T>
>
class PPoolTimerArg1: public PPoolTimer<Base_T, Pool_T>
{
    typedef PPoolTimer<Base_T, Pool_T> BaseClass;
    PCLASSINFO(PPoolTimerArg1, BaseClass);
  protected:
    Arg1 m_arg1;
  public:
    PPoolTimerArg1(Pool_T & pool, Arg1 arg1)
      : BaseClass(pool)
      , m_arg1(arg1)
    {
    }

    virtual Work_T * CreateWork() { return new Work_T(m_arg1); }

    PTIMER_OPERATORS(PPoolTimerArg1);
};


template <
  class Work_T,
  typename Arg1,
  typename Arg2,
  class Base_T = Work_T,
  class Pool_T = PQueuedThreadPool<Base_T>
>
class PPoolTimerArg2: public PPoolTimer<Base_T, Pool_T>
{
    typedef PPoolTimer<Base_T, Pool_T> BaseClass;
    PCLASSINFO(PPoolTimerArg2, BaseClass);
  protected:
    Arg1 m_arg1;
    Arg2 m_arg2;
  public:
    PPoolTimerArg2(Pool_T & pool, Arg1 arg1, Arg2 arg2)
      : BaseClass(pool)
      , m_arg1(arg1)
      , m_arg2(arg2)
    {
    }

    virtual Work_T * CreateWork() { return new Work_T(m_arg1, m_arg2); }

    PTIMER_OPERATORS(PPoolTimerArg2);
};


template <
  class Work_T,
  typename Arg1,
  typename Arg2,
  typename Arg3,
  class Base_T = Work_T,
  class Pool_T = PQueuedThreadPool<Base_T>
>
class PPoolTimerArg3: public PPoolTimer<Base_T, Pool_T>
{
    typedef PPoolTimer<Base_T, Pool_T> BaseClass;
    PCLASSINFO(PPoolTimerArg3, BaseClass);
  protected:
    Arg1 m_arg1;
    Arg2 m_arg2;
    Arg3 m_arg3;
  public:
    PPoolTimerArg3(Pool_T & pool, Arg1 arg1, Arg2 arg2, Arg3 arg3)
      : BaseClass(pool)
      , m_arg1(arg1)
      , m_arg2(arg2)
      , m_arg3(arg3)
    {
    }

    virtual Work_T * CreateWork() { return new Work_T(m_arg1, m_arg2, m_arg3); }

    PTIMER_OPERATORS(PPoolTimerArg3);
};


#endif // PTLIB_TIMER_H


// End Of File ///////////////////////////////////////////////////////////////