transition.h

Go to the documentation of this file.

#pragma once

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

namespace escad {

namespace new_fsm {

namespace detail {

struct none {};

template <class T> struct sibling {
  using type = T;
};

template <class T> struct inner {
  using type = T;
};

template <class T> struct inner_entry {
  using type = T;
};

enum class result { none, sibling, inner, inner_entry };

} // namespace detail

template <class... S> class transitions {
  using result = detail::result;

public:
  template <class... T>
  constexpr transitions(transitions<T...> const &rhs) noexcept
      : idx{0}, outcome{rhs.outcome} {}

  template <class T>
  transitions(detail::sibling<T>) noexcept
      : idx{mpl::type_list_index_v<T, list>}, outcome{result::sibling} {}
  
    template <class T>
  transitions(detail::inner<T>) noexcept
      : idx{mpl::type_list_index_v<T, list>}, outcome{result::inner} {}

      template <class T>
  transitions(detail::inner_entry<T>) noexcept
      : idx{mpl::type_list_index_v<T, list>}, outcome{result::inner_entry} {}
  
  template <class T>
  transitions(transitions<T> const &rhs) noexcept
      : idx{mpl::type_list_index_v<T, list>}, outcome{rhs.outcome} {}

  transitions(detail::none) noexcept
      : idx{mpl::type_list_index_v<detail::none, list>}, outcome{result::none} {
  }

  transitions(transitions<detail::none>) noexcept
      : idx{mpl::type_list_index_v<detail::none, list>}, outcome{result::none} {
  }

  bool is_transition() const { return outcome == result::sibling; }

  bool is_sibling() const { return outcome == result::sibling; }

  bool is_inner() const { return outcome == result::inner; }

  bool is_inner_entry() const { return outcome == result::inner_entry; }

  bool is_none() const { return outcome == result::none; }

  using list = mpl::type_list<S...>;

  std::size_t const idx;
  result const outcome;
};

template <class S> inline auto sibling() {
  return transitions<S>{detail::sibling<S>{}};
}

template <class S> inline auto inner() {
  return transitions<S>{detail::inner<S>{}};
}

template <class S> inline auto inner_entry() {
  return transitions<S>{detail::inner_entry<S>{}};
}

inline auto none() { return transitions<detail::none>{detail::none{}}; }

template <std::size_t Index, class Transition>
using transition_t = mpl::type_list_element_t<Index, typename Transition::list>;

template <class Transition, class Func, std::size_t... Is>
constexpr void for_each_transition_impl(Transition &&t, Func &&func,
                                        std::index_sequence<Is...>) {
  (func(std::integral_constant<std::size_t, Is>{}, t), ...);
}

template <class... T, class Func>
constexpr void for_each_transition(transitions<T...> const &trans,
                                   Func &&func) {
  for_each_transition_impl(trans, std::forward<Func>(func),
                           std::make_index_sequence<sizeof...(T)>{});
}

} // namespace new_fsm
} // namespace escad