timer.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD 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 General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef TIMER_H
#define TIMER_H
 
#include "timer_manager.h"
 
 
template <typename TTimerType>
class BaseTimer {
public:
  using TPeriod = typename TTimerType::TPeriod;
  using TElapsed = typename TTimerType::TElapsed;
  using TStorage = typename TTimerType::TStorage;
 
  [[nodiscard]] BaseTimer(const TPeriod period) :
    period(period)
  {
    TimerManager<TTimerType>::RegisterTimer(*this);
  }
 
  virtual ~BaseTimer()
  {
    TimerManager<TTimerType>::UnregisterTimer(*this);
  }
 
  /* Although these variables are public, they are only public to make saveload easier; not for common use. */
 
  TPeriod period; 
  TStorage storage = {}; 
 
protected:
  virtual void Elapsed(TElapsed delta) = 0;
 
  /* To ensure only TimerManager can access Elapsed. */
  friend class TimerManager<TTimerType>;
};
 
template <typename TTimerType>
class IntervalTimer : public BaseTimer<TTimerType> {
public:
  using TPeriod = typename TTimerType::TPeriod;
  using TElapsed = typename TTimerType::TElapsed;
 
  [[nodiscard]] IntervalTimer(const TPeriod interval, std::function<void(uint)> callback) :
    BaseTimer<TTimerType>(interval),
    callback(callback)
  {
  }
 
  void SetInterval(const TPeriod interval, bool reset = true)
  {
    TimerManager<TTimerType>::ChangeRegisteredTimerPeriod(*this, interval);
    if (reset) this->storage = {};
  }
 
private:
  std::function<void(uint)> callback;
 
  void Elapsed(TElapsed count) override;
};
 
template <typename TTimerType>
class TimeoutTimer : public BaseTimer<TTimerType> {
public:
  using TPeriod = typename TTimerType::TPeriod;
  using TElapsed = typename TTimerType::TElapsed;
 
  [[nodiscard]] TimeoutTimer(const TPeriod timeout, std::function<void()> callback, bool start = false) :
    BaseTimer<TTimerType>(timeout),
    fired(!start),
    callback(callback)
  {
  }
 
  void Reset()
  {
    this->fired = false;
    this->storage = {};
  }
 
  void Reset(const TPeriod timeout)
  {
    TimerManager<TTimerType>::ChangeRegisteredTimerPeriod(*this, timeout);
    this->fired = false;
    this->storage = {};
  }
 
  void Abort()
  {
    this->fired = true;
  }
 
  bool HasFired() const
  {
    return this->fired;
  }
 
  /* Although these variables are public, they are only public to make saveload easier; not for common use. */
 
  bool fired; 
 
private:
  std::function<void()> callback;
 
  void Elapsed(TElapsed count) override;
};
 
#endif /* TIMER_H */