Engine.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_timex_Engine_hpp
#define anna_timex_Engine_hpp

#include <pthread.h>

#include <vector>
#include <map>

#include <anna/app/Component.hpp>

#include <anna/timex/TimeEvent.hpp>

namespace anna {

class Thread;

namespace timex {

class TickProducer;
class TickConsumer;

namespace st {
class TickProducer;
}

namespace mt {
class TickProducer;
}

class Engine : public app::Component {
public:
  static const Millisecond minResolution;

  Engine(const Millisecond & maxTimeout, const Millisecond & resolution);

  virtual ~Engine();

  const Millisecond & getResolution() const { return a_resolution; }

  const Millisecond & getMaxTimeout() const { return a_maxTimeout; }

  void pause() noexcept(false);

  void play() noexcept(false);

  void activate(TimeEvent* timeEvent) noexcept(false);

  void activate(TimeEvent& timeEvent) noexcept(false) { activate(&timeEvent); }

  void cancel(TimeEvent* timeEvent) noexcept(false);

  void cancel(TimeEvent& timeEvent) noexcept(false) { cancel(&timeEvent); }

  TimeEvent* getTimeEvent(const TimeEvent::Id eventTimeId) ;

  virtual void eventBeginQuantum() noexcept(false) {;}

  virtual void eventEndQuantum(const int quantumSize) noexcept(false) {;}

  virtual std::string asString() const ;

  virtual xml::Node* asXML(xml::Node* parent) const ;

  static const char* getClassName() { return "anna::timex::Engine"; }

private:
  typedef std::vector <TimeEvent*> Quantum;
  typedef Quantum::iterator quantum_iterator;
  typedef std::map <TimeEvent::Id, Quantum*> Directory;

  Quantum* a_timeTable;
  Engine::Directory a_directory;
  int a_currentQuantum;
  int a_maxQuantum;
  Millisecond a_resolution;
  Millisecond a_maxTimeout;
  bool a_isActive;
  TickProducer* a_tickProducer;
  TickConsumer* a_tickConsumer;
  Thread* a_thread;
  Quantum* a_expiredQuantum;
  Quantum a_delayedQuantum;
  pthread_t a_threadProducer;

  void do_initialize() noexcept(false);
  void do_stop() ;
  void kill() ;

  void tick() noexcept(false);
  int getQuantum(const int timeout) const { return (a_currentQuantum + (timeout / a_resolution)) % a_maxQuantum; }
  void calibrate() ;

  // Reimplementado de app::Component
  void do_cloneParent() ;
  void do_cloneChild() noexcept(false);

  static void notifyRelease(TimeEvent* timeEvent) ;
  static TimeEvent* timeEvent(quantum_iterator& ii) { return *ii; }

  friend class TickProducer;
  friend class TickConsumer;
  friend class st::TickProducer;
  friend class mt::TickProducer;
};

}
}

#endif