dummy-tick-service.hpp

Go to the documentation of this file.

/*
  DUMMY-TICK-SERVICE.hpp  -  issuing timed callbacks
 
   Copyright (C)
    2009,               Joel Holdsworth <joel@airwebreathe.org.uk>,
                        Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** 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; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
*/
 
#ifndef STEAM_PLAY_DUMMY_TICK_SERVICE_H
#define STEAM_PLAY_DUMMY_TICK_SERVICE_H
 
 
#include "lib/error.hpp"
#include "lib/thread.hpp"
 
#include <unistd.h>   // for usleep()
 
#include <functional>
#include <limits>
#include <atomic>
 
 
namespace steam {
namespace node {
 
  using std::function;
  using std::bind;
  
  
  
  /********************************************************/
  class DummyTickService
    : lib::ThreadJoinable<>
    {
      using Tick = function<void(void)>;
      std::atomic_uint timespan_;
      
      static const uint POLL_TIMEOUT = 10000;
      
    public:
      DummyTickService (Tick callback)
        : ThreadJoinable("Tick generator (dummy)"
                        , bind (&DummyTickService::timerLoop, this, callback)
                        )
        , timespan_{POLL_TIMEOUT}
        {
          INFO (steam, "DummyTickService started.");
        }
      
     ~DummyTickService ()
        {
          timespan_ = 0;
          if (not this->join())
            WARN (steam, "Failure in DummyTickService");
          
          usleep (200000);    // additional delay allowing GTK to dispatch the last output
          INFO (steam, "DummyTickService shutdown.");
        }
      
      
      void activate (uint fps)
        {
          REQUIRE (  0==fps
                  or(    1000000/fps < std::numeric_limits<uint>::max()
                     and 1000000/fps > POLL_TIMEOUT));
          if (fps)
            timespan_ = 1000000/fps; // microseconds per tick
          else
            timespan_ = POLL_TIMEOUT;
        }
      
      
    private:
      void timerLoop(Tick periodicFun)
        {
          do
            {
              if (timespan_ > POLL_TIMEOUT)
                periodicFun();
              
              usleep (timespan_);
            }
          while (timespan_);   //(possible yet very unlikely race with ctor)
          //
          TRACE (proc_dbg, "Tick Thread timer loop exiting...");
        }
 
    };
  
  
  
}} // namespace steam::node
#endif /*STEAM_PLAY_DUMMY_TICK_SERVICE_H*/