C:/knet/include/kNet/PolledTimer.h

Go to the documentation of this file.

/* Copyright 2010 Jukka Jylänki

   Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License. */
#pragma once

#include "Clock.h"

namespace kNet
{

class PolledTimer
{
public:
   PolledTimer():enabled(false)
   {
      startTime = Clock::Tick();
   }

   explicit PolledTimer(float msecs)
   :enabled(false)
   {
      StartMSecs(msecs);
   }

   void StartMSecs(float msecs)
   {
      StartTicks((tick_t)(Clock::TicksPerSec() * (msecs / 1000.f)));
   }

   void StartTicks(tick_t ticks)
   {
      startTime = Clock::Tick();
      alarmTime = startTime + ticks;
      enabled = true;
   }

   void Stop()
   {
      enabled = false;
   }

   void Reset()
   {
      Stop();
   }

   tick_t TicksElapsed() const
   {
      return Clock::Tick() - startTime;
   }

   float MSecsElapsed() const
   {
      return Clock::TicksToMillisecondsF(TicksElapsed());
   }

   void Start()
   {
      enabled = false; // The target-timer is disabled.
      startTime = Clock::Tick(); // Start counting from now.
   }

   bool Enabled() const
   {
      return enabled;
   }

   bool Test()
   {
      if (!enabled)
         return false;
      if (Clock::IsNewer(Clock::Tick(), alarmTime))
      {
         Reset();
         return true;
      }
      return false;
   }

   bool TriggeredOrNotRunning()
   {
      return Test() || !Enabled();
   }

   tick_t TicksLeft() const
   {
      if (!enabled)
         return (tick_t)(-1);

      tick_t now = Clock::Tick();
      if (Clock::IsNewer(now, alarmTime))
         return 0;
      else
         return Clock::TicksInBetween(alarmTime, now);
   }

   float MSecsLeft() const
   {
      if (!enabled)
         return -1.f;

      tick_t now = Clock::Tick();
      if (Clock::IsNewer(now, alarmTime))
         return 0.f;
      else
         return Clock::TimespanToMillisecondsF(now, alarmTime);
   }

   void WaitPrecise()
   {
      if (!enabled)
         return;

      tick_t timeLeft = TicksLeft();
      while(timeLeft > 0)
      {
         if (timeLeft > Clock::TicksPerMillisecond())
         {
            float msecs = Clock::TicksToMillisecondsF(timeLeft);
            Clock::Sleep((int)msecs);
         }
         else // If there's less than one ms left, we use spinwait to return precisely as near to the correct tick as possible.
         {
            SpinWait();
            return;
         }
         timeLeft = TicksLeft();
      }
   }

   void SpinWait()
   {
      while(enabled && TicksLeft() > 0)
         ;
   }

private:
   bool enabled;
   tick_t alarmTime;
   tick_t startTime;
};

} // ~kNet