event_loop.h

Go to the documentation of this file.

#ifndef REACTESP_SRC_EVENT_LOOP_H_
#define REACTESP_SRC_EVENT_LOOP_H_
 
#include <set>
#include <vector>
 
#include "events.h"
 
namespace reactesp {

class EventLoop {
  friend class Event;
  friend class TimedEvent;
  friend class RepeatEvent;
  friend class UntimedEvent;
  friend class ISREvent;
 
 public:
  EventLoop()
      : timed_events_(), untimed_list(), isr_event_list() {
    timed_queue_mutex_ = xSemaphoreCreateRecursiveMutex();
    untimed_list_mutex_ = xSemaphoreCreateRecursiveMutex();
    isr_event_list_mutex_ = xSemaphoreCreateRecursiveMutex();
 
    // Initialize the mutexes
 
    xSemaphoreGiveRecursive(timed_queue_mutex_);
    xSemaphoreGiveRecursive(untimed_list_mutex_);
    xSemaphoreGiveRecursive(isr_event_list_mutex_);
  }
 
  // Disabling copy constructors
  EventLoop(const EventLoop&) = delete;
  EventLoop(EventLoop&&) = delete;
 
  int getTimedEventQueueSize() { return timed_events_.size(); }
  int getUntimedEventQueueSize() { return untimed_list.size(); }
  int getISREventQueueSize() { return isr_event_list.size(); }
  int getEventQueueSize() {
    return getTimedEventQueueSize() + getUntimedEventQueueSize() +
           getISREventQueueSize();
  }
 
  uint64_t getTimedEventCount() { return timed_event_counter; }
  uint64_t getUntimedEventCount() { return untimed_event_counter; }
  uint64_t getEventCount() {
    return getTimedEventCount() + getUntimedEventCount();
  }
 
  uint64_t getTickCount() { return tick_counter; }
 
  void tick();

  DelayEvent* onDelay(uint32_t delay, react_callback callback);
  DelayEvent* onDelayMicros(uint64_t delay, react_callback callback);
  RepeatEvent* onRepeat(uint32_t interval, react_callback callback);
  RepeatEvent* onRepeatMicros(uint64_t interval, react_callback callback);
  StreamEvent* onAvailable(Stream& stream, react_callback callback);
  ISREvent* onInterrupt(uint8_t pin_number, int mode, react_callback callback);
  TickEvent* onTick(react_callback callback);
 
  void remove(TimedEvent* event);
  void remove(UntimedEvent* event);
  void remove(ISREvent* event);

  void remove(Event* event);
 
 protected:
  // Timed events are stored in an ordered set, sorted by trigger time (with
  // pointer tiebreaker for total ordering). This allows O(log n) removal of
  // specific events, avoiding the zombie-event accumulation that occurred
  // with the previous priority_queue + lazy-delete approach.
  // The hot path uses C++17 extract()/insert() to reuse tree nodes without
  // heap allocation; under C++14 it falls back to erase()/insert(), which
  // does one heap alloc + dealloc per RepeatEvent tick.
  using TimedEventSet = std::set<TimedEvent*, TriggerTimeCompare>;
  TimedEventSet timed_events_;
  // Untimed events are stored in a vector, which is traversed in order.
  // Elements are rarely removed from the middle of the list, so a vector is
  // acceptable.
  std::vector<UntimedEvent*> untimed_list;
  // ISR events are stored in a vector. The list is traversed or modified
  // infrequently.
  std::vector<ISREvent*> isr_event_list;
 
  // Semaphores for accessing the above queues and lists
  SemaphoreHandle_t timed_queue_mutex_;
  SemaphoreHandle_t untimed_list_mutex_;
  SemaphoreHandle_t isr_event_list_mutex_;
 
  uint64_t timed_event_counter = 0;
  uint64_t untimed_event_counter = 0;
  uint64_t tick_counter = 0;
 
  void tickTimed();
  void tickUntimed();
};
 
// Provide compatibility aliases for the old naming scheme
 
using ReactESP = EventLoop;
using TimedReaction = TimedEvent;
using UntimedReaction = UntimedEvent;
using DelayReaction = DelayEvent;
using RepeatReaction = RepeatEvent;
using ISRReaction = ISREvent;
using StreamReaction = StreamEvent;
using TickReaction = TickEvent;
 
}  // namespace reactesp
 
#endif  // REACTESP_SRC_EVENT_LOOP_H_