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): ______________________________________.
 */

#ifndef PTLIB_TIMER_H
#define PTLIB_TIMER_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <ptlib_config.h>

#if P_TIMERS

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

    void Stop();

    PTimeInterval GetElapsed() const;

    PTimeInterval GetRemaining() const;

    bool IsRunning() const;

    bool HasExpired() const;

    operator bool() const;

  protected:
    virtual void InternalSet(int64_t t);
    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;

    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,  
      const PString & threadName = PString::Empty()  
    );

    PPROFILE_EXCLUDE(
    static PTimeInterval Tick()
    );

    static unsigned Resolution();


    /* 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 ~Timeout() { }
          virtual void Work();
        };
        PQueuedThreadPool<Timeout> m_threadPool;

        typedef std::map<PIdGenerator::Handle, PTimer *> TimerMap;
        TimerMap m_timers;
        PCriticalSection m_timersMutex;
#if PTRACING
        size_t m_highWaterMark;
#endif

      friend class PTimer;
    };

    static List * TimerList();


  private:
    virtual int64_t InternalGet() const;
    virtual void InternalSet(int64_t t);
    void InternalStart(bool once, int64_t resetTime);

    // Member variables
    PNotifier            m_callback;     // Callback function for expired timers.
    PString              m_threadName;
    bool                 m_oneshot;      // Timer operates once then stops.
    PIdGenerator::Handle m_handle;
    atomic<bool>         m_running;
    PTimeInterval        m_absoluteTime;
    mutable 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;
    bool     m_stopped;
  public:
    PPoolTimer(Pool_T & pool)
      : m_pool(pool)
      , m_stopped(false)
    {
    }

    ~PPoolTimer()
    {
      m_stopped = true;
    }

    virtual void OnTimeout()
    {
      if (m_stopped)
        return;
      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);
};


#else

namespace PTimer
{
  PTimeInterval Tick();
  unsigned Resolution();
};

#endif // P_TIMERS

#endif // PTLIB_TIMER_H


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