sm_event.h

/*
 * Developer : Alexey Zakharov (alexey.zakharov@vectioneer.com)
 * All rights reserved. Copyright (c) 2014-2016 VECTIONEER.
 */
 
#ifndef STATE_MACHINE_SM_EVENT_H
#define STATE_MACHINE_SM_EVENT_H
 
#include "utl_log.h"
#include <cstdint>
 
namespace mcx::state_machine {
 
enum EventPriority {
  HIGH_PRIORITY_EVENT = 0,
  LOW_PRIORITY_EVENT = 1,
};
 
enum EventStatus {
  EVENT_NONE = -1,
  EVENT_DONE = 0,
  EVENT_DELAY = 1,
  EVENT_REPEAT = 2,
  EVENT_TERMINATE = 3,
  EVENT_REPEAT_NO_TERMINATE = 4
};
 
template <class R>
struct DR {
  typedef R T;
};
 
template <class R>
struct DR<R&> {
  typedef R T;
};
 
template <class R>
struct DR<const R&> {
  typedef R T;
};
 
template <class STATE>
class Event {
  typedef EventStatus (STATE::*Signature)();
 
public:
  Event() : onceExecutedFlag_(false), timeoutSec_(0), termFunc_(nullptr) {}
 
  virtual ~Event() = default;
 
  virtual EventStatus dispatchEvent(STATE* state) = 0;
 
  void setTerminateFunc(Signature term_func) { termFunc_ = term_func; }
 
  const Signature& getTerminateFunc() { return termFunc_; }
 
  void setExecutedOnceFlag(bool once_executed_flag) { onceExecutedFlag_ = once_executed_flag; }
 
  bool getExecutedOnceFlag() { return onceExecutedFlag_; }
 
  void setTimeoutSec(double timeout_sec) { timeoutSec_ = timeout_sec; }
 
  double getTimeoutSec() { return timeoutSec_; }
 
  virtual bool compare(const Event* cmp) { return false; }
 
protected:
  bool onceExecutedFlag_;
  double timeoutSec_;
  Signature termFunc_;
};
 
template <class STATE>
class _Event0 : public Event<STATE> {
  typedef EventStatus (STATE::*Signature)();
 
public:
  _Event0(Signature event_func) : eventFunc_(event_func) {}
 
  virtual ~_Event0() = default;
 
  EventStatus dispatchEvent(STATE* state) { return (state->*eventFunc_)(); }
 
  bool compare(const Event<STATE>* cmp) { return (static_cast<const _Event0<STATE>*>(cmp))->eventFunc_ == eventFunc_; }
 
protected:
  Signature eventFunc_;
};
 
template <class STATE, class P1>
class _Event1 : public Event<STATE> {
  typedef EventStatus (STATE::*Signature)(P1);
 
public:
  _Event1(Signature event_func, const typename DR<P1>::T& param1) : eventFunc_(event_func), param1_(param1) {}
 
  EventStatus dispatchEvent(STATE* state) { return (state->*eventFunc_)(param1_); }
 
  bool compare(const Event<STATE>* cmp) {
    return (static_cast<const _Event1<STATE, P1>*>(cmp))->eventFunc_ == eventFunc_;
  }
 
protected:
  Signature eventFunc_;
  const typename DR<P1>::T param1_;
};
 
template <class STATE, class P1, class P2>
class _Event2 : public Event<STATE> {
  typedef EventStatus (STATE::*Signature)(P1, P2);
 
public:
  _Event2(Signature event_func, const typename DR<P1>::T& param1, const typename DR<P2>::T& param2)
      : eventFunc_(event_func), param1_(param1), param2_(param2) {}
 
  EventStatus dispatchEvent(STATE* state) { return (state->*eventFunc_)(param1_, param2_); }
 
  bool compare(const Event<STATE>* cmp) {
    return (static_cast<const _Event2<STATE, P1, P2>*>(cmp))->eventFunc_ == eventFunc_;
  }
 
protected:
  Signature eventFunc_;
  const typename DR<P1>::T param1_;
  const typename DR<P2>::T param2_;
};
 
template <class STATE, class P1, class P2, class P3>
class _Event3 : public Event<STATE> {
  typedef EventStatus (STATE::*Signature)(P1, P2, P3);
 
public:
  _Event3(Signature event_func, const typename DR<P1>::T& param1, const typename DR<P2>::T& param2,
          const typename DR<P3>::T& param3)
      : eventFunc_(event_func), param1_(param1), param2_(param2), param3_(param3) {}
 
  EventStatus dispatchEvent(STATE* state) { return (state->*eventFunc_)(param1_, param2_, param3_); }
 
  bool compare(const Event<STATE>* cmp) {
    return (static_cast<const _Event3<STATE, P1, P2, P3>*>(cmp))->eventFunc_ == eventFunc_;
  }
 
protected:
  Signature eventFunc_;
  const typename DR<P1>::T param1_;
  const typename DR<P2>::T param2_;
  const typename DR<P3>::T param3_;
};
 
template <class STATE>
class EventBase {
protected:
  Event<STATE>* event_;
 
public:
  virtual ~EventBase() = default;
 
  Event<STATE>* getEvent() const { return event_; }
};
 
template <class STATE>
class Event0 : public EventBase<STATE> {
public:
  Event0(EventStatus (STATE::*event)()) { this->event_ = new _Event0<STATE>(event); }
};
 
template <class STATE>
class Event1 : public EventBase<STATE> {
public:
  template <class P1>
  Event1(EventStatus (STATE::*event)(P1), const typename DR<P1>::T& p1 = {}) {
    this->event_ = new _Event1<STATE, P1>(event, p1);
  }
};
 
template <class STATE>
class Event2 : public EventBase<STATE> {
public:
  template <class P1, class P2>
  Event2(EventStatus (STATE::*event)(P1, P2), const typename DR<P1>::T& p1 = {}, const typename DR<P2>::T& p2 = {}) {
    this->event_ = new _Event2<STATE, P1, P2>(event, p1, p2);
  }
};
 
template <class STATE>
class Event3 : public EventBase<STATE> {
public:
  template <class P1, class P2, class P3>
  Event3(EventStatus (STATE::*event)(P1, P2, P3), const typename DR<P1>::T& p1 = {}, const typename DR<P2>::T& p2 = {},
         const typename DR<P3>::T& p3 = {}) {
    this->event_ = new _Event3<STATE, P1, P2, P3>(event, p1, p2, p3);
  }
};
 
} // namespace mcx::state_machine
 
#endif // STATE_MACHINE_SM_EVENT_H