TimedExecutor.h

Go to the documentation of this file.

#ifndef _MADARA_TIMED_EXECUTOR_H_
#define _MADARA_TIMED_EXECUTOR_H_

#include <vector>
#include <map>
#include <string>
#include <utility>
#include <queue>
#include "madara/LockType.h"
#include "madara/knowledge/KnowledgeBase.h"
#include "madara/knowledge/EvalSettings.h"
#include "madara/expression/ComponentNode.h"

#include "ace/High_Res_Timer.h"
#include "ace/Barrier.h"
#include "ace/Mutex.h"
#include "ace/Thread_Mutex.h"

namespace madara
{
  namespace knowledge
  {
    struct Event
    {
      ACE_Time_Value delay;

      ACE_Time_Value period;
      
#ifndef _MADARA_NO_KARL_
      expression::ComponentNode * root;
#endif // _MADARA_NO_KARL_

      KnowledgeBase * knowledge;

      unsigned int executions;

      int intended_executions;

      bool cancel_on_false;
    };

    struct TimedEventThreadInfo;

    class TimedEventThread;

    typedef std::pair <ACE_Time_Value, Event *> TimedEvent;

    class MADARA_Export TimedExecutor
    {
    public:
      TimedExecutor ();
      
      ~TimedExecutor ();

      void add (const TimedEvent & new_event);
      
      void add (const Event & new_event);

      ACE_Time_Value remove (TimedEvent & cur_event);

      void shutdown (void);

      bool is_shutdown (void);

      ACE_Time_Value time_until_next (void);
      
      void launch_threads (unsigned int threads);

      void enter_barrier (void);
      
      void clear_queue (void);

      knowledge::KnowledgeRecord::Integer num_threads (void);

    private:
      

      
      
      typedef std::priority_queue <TimedEvent, std::vector <TimedEvent> >
        PriorityQueue;

      void lock (void);

      void unlock (void);

      mutable MADARA_LOCK_TYPE mutex_;
      
      PriorityQueue events_;

      TimedEventThreadInfo * thread_info_;

      TimedEventThread ** threads_;

      knowledge::KnowledgeRecord::Integer num_threads_;

      KnowledgeBase control_plane_;

      VariableReference threads_ref_;

      VariableReference queue_size_;

      VariableReference terminated_;
    };

    struct TimedEventThreadInfo
    {
      TimedExecutor * executor;
      
      KnowledgeBase * control_plane;

      unsigned int id;
    };

    MADARA_Export Event fill_event (
      KnowledgeBase & knowledge,
      const std::string & expression,
      double delay = 0.0, double period = 0.0, int executions = -1);
  }
}

bool operator< (
  const madara::knowledge::TimedEvent & lhs,
  const madara::knowledge::TimedEvent & rhs);



#endif // _MADARA_TIMED_EXECUTOR_H_