state.h

Go to the documentation of this file.

#pragma once

#include <optional>
#include <type_traits>

#include "../base/type_traits.h"
#include "transition.h"

namespace escad {
namespace new_fsm {

namespace detail {

struct NoContext {};

struct InternalEvent {};

template <typename Target, typename = void>
struct has_onEnter : std::false_type {};

template <typename Target>
struct has_onEnter<Target,
                   std::void_t<decltype(std::declval<Target>().onEnter())>>
    : std::true_type {};

template <class T> inline constexpr bool has_onEnter_v = has_onEnter<T>::value;

template <typename Target, typename Event, typename = void>
struct has_onEnterWithEvent : std::false_type {};

template <typename Target, typename Event>
struct has_onEnterWithEvent<Target, Event,
                            std::void_t<decltype(std::declval<Target>().onEnter(
                                std::declval<Event>()))>> : std::true_type {};

template <class T, class E>
inline constexpr bool has_onEnterWithEvent_v =
    has_onEnterWithEvent<T, E>::value;

template <typename Target, typename = void>
struct has_onExit : std::false_type {};

template <typename Target>
struct has_onExit<Target,
                  std::void_t<decltype(std::declval<Target>().onExit())>>
    : std::true_type {};

template <class T> inline constexpr bool has_onExit_v = has_onExit<T>::value;

template <typename Target, typename Event, typename = void>
struct has_transitionTo : std::false_type {};

template <typename Target, typename Event>
struct has_transitionTo<
    Target, Event,
    std::void_t<decltype(std::declval<Target>().transitionTo(
        std::declval<Event>()))>> : std::true_type {};

template <class T, class E>
inline constexpr bool has_transitionTo_v = has_transitionTo<T, E>::value;

template <typename Target, typename = void>
struct has_transitionInternalTo : std::false_type {};

template <typename Target>
struct has_transitionInternalTo<
    Target,
    std::void_t<decltype(std::declval<Target>().transitionInternalTo())>>
    : std::true_type {};

template <class T>
inline constexpr bool has_transitionInternalTo_v =
    has_transitionInternalTo<T>::value;

} // namespace detail

template <class... S> struct states {
  using type_list = mpl::type_list<S...>;
  static constexpr auto count = type_list::size;
};

template <class Derived, class Context = detail::NoContext> struct state {
  using ctx = Context;

  // state() : context_{} {}
  state(Context &context) : context_(context) {}

  template <class Target = Derived, class Event>
  bool enter(const Event &event) {
    if constexpr (detail::has_onEnterWithEvent_v<Target, Event>) {
      static_cast<Target *>(this)->onEnter(event);
      return true;
    }
    return false;
  }

  template <class Target = Derived> bool enter() {
    if constexpr (detail::has_onEnter_v<Target>) {
      static_cast<Target *>(this)->onEnter();
      return true;
    }
    return false;
  }

  template <class Target = Derived> bool exit() {
    if constexpr (detail::has_onExit_v<Target>) {
      static_cast<Target *>(this)->doRun();
      return true;
    }
    return false;
  }

  template <class Target = Derived, class Event>
  auto transition(const Event &event)
      -> decltype(std::declval<Target>().transitionTo(event)) {
    if constexpr (detail::has_transitionTo_v<Target, Event>) {
      return static_cast<Target *>(this)->transitionTo(event);
    }
  }

  template <class Target = Derived>
  auto transition(...) -> transitions<detail::none> {
    return detail::none{};
  }

  template <class Target = Derived>
  auto transitionInternal()
      -> decltype(std::declval<Target>().transitionInternalTo()) {
    if constexpr (detail::has_transitionInternalTo_v<Target>) {
      return static_cast<Target *>(this)->transitionInternalTo();
    }
    // return detail::none{};
  }

  // template <class Target = Derived>
  //  auto transitionInternal(...) -> transitions<detail::none> {
  //    return detail::none{};
  //  }

  template <class Event> bool dispatch(const Event &) { return false; }

  const Context &context() { return context_; }

protected:
  Context &context_;
};

} // namespace new_fsm
} // namespace escad