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: 32010 $
 * $Author: rjongbloed $
 * $Date: 2014-05-31 14:52:42 +1000 (Sat, 31 May 2014) $
 */

#ifndef PTLIB_TIMER_H
#define PTLIB_TIMER_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif


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

#include <queue>
#include <set>
#include <map>


// 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_WITH_CLONE(PTimer, PTimeInterval);

  public:

    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          
    );

    PTIMER_OPERATORS(PTimer);

    virtual ~PTimer();

    virtual void PrintOn(
      ostream & strm    
    ) const;

    virtual void SetMilliSeconds(PInt64 msecs);

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

    void Stop(
      bool wait = true
    );

    PBoolean IsRunning() const;

    void Reset();

    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;


    /* This class defines a list of <code>PTimer</code> objects. It is primarily used
       internally by the library and the user should never create an instance of
       it. The <code>PProcess</code> instance for the application maintains an instance
       of all of the timers created so that it may decrements them at regular
       intervals.
     */
    class List
    {
      public:
        // Create a new timer list
        List();

        /* Decrement all the created timers and dispatch to their callback
           functions if they have expired. The <code>PTimer::Tick()</code> function
           value is used to determine the time elapsed since the last call to
           Process().

           The return value is the number of milliseconds until the next timer
           needs to be dispatched. The function need not be called again for this
           amount of time, though it can (and usually is).
       
           @return
           maximum time interval before function should be called again.
         */
        PTimeInterval Process();

      private:
        bool OnTimeout(PIdGenerator::Handle handle);

        struct Timeout
        {
          PIdGenerator::Handle m_handle;
          Timeout(PIdGenerator::Handle handle) : m_handle(handle) { }
          virtual void Work();
        };
        PQueuedThreadPool<Timeout> m_threadPool;

        typedef std::map<PIdGenerator::Handle, PTimer *> TimerMap;
        TimerMap m_timers;
        PMutex   m_timersMutex;

      friend class PTimer;
    };

    static List * TimerList();


  private:
    void InternalStart(bool once, PTimeInterval resetTime); // Note, not "const PTimeInterval &" to avoid mutex issues

    // Member variables
    PNotifier            m_callback;     // Callback function for expired timers.
    bool                 m_oneshot;      // Timer operates once then stops.
    PIdGenerator::Handle m_handle;
    bool                 m_running;
    PTimeInterval        m_absoluteTime;
    PTimedMutex          m_callbackMutex;

    friend class Emitter;

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