compiler failure when combining actions and a logger

[rhaschke]

compiler failure when combining actions and a logger

[Schoppenglas]

Just wrap ur calls. See:

#include <boost/sml.hpp>
#include <cassert>
#include <iostream>

namespace sml = boost::sml;

namespace {
struct printf_logger
{
  template <class SM, class TEvent>
  void log_process_event(const TEvent&)
  {
    std::printf("[%s][event] %s\n", sml::aux::get_type_name<SM>(), sml::aux::get_type_name<TEvent>());
  }

  template <class SM, class TGuard, class TEvent>
  void log_guard(const TGuard&, const TEvent&, bool result)
  {
    std::printf("[%s][guard] %s(%s): %s\n", sml::aux::get_type_name<SM>(), sml::aux::get_type_name<TGuard>(),
                sml::aux::get_type_name<TEvent>(), (result ? "accept" : "reject"));
  }

  template <class SM, class TAction, class TEvent>
  void log_action(const TAction&, const TEvent&)
  {
    std::printf("[%s][action] %s(%s)\n", sml::aux::get_type_name<SM>(), sml::aux::get_type_name<TAction>(),
                sml::aux::get_type_name<TEvent>());
  }

  template <class SM, class TSrcState, class TDstState>
  void log_state_change(const TSrcState& src, const TDstState& dst)
  {
    std::printf("[%s][transition] %s -> %s\n", sml::aux::get_type_name<SM>(), src.c_str(), dst.c_str());
  }
};

struct connect {
  int id{};
};
struct disconnect {};
struct interrupt {};

struct Disconnected {};
struct Connected {
  int id{};  /// per state data
};
struct Interrupted {
  int id{};  /// per state data
};

class data {
  using Self = data;

 public:
  explicit data(const std::string& address) : address{address} {}

  auto operator()() {
    using namespace boost::sml;

    const auto set = [](const auto& event, Connected& state) { state.id = event.id; };
    const auto update = [](Connected& src_state, Interrupted& dst_state) { dst_state.id = src_state.id; };

    // clang-format off
    return make_transition_table(
      * state<Disconnected> + event<connect>    / (set, wrap(&Self::print))    = state<Connected>
      , state<Connected>    + event<interrupt>  / (update, wrap(&Self::print)) = state<Interrupted>
      , state<Interrupted>  + event<connect>    / (set, wrap(&Self::print))    = state<Connected>
      , state<Connected>    + event<disconnect> / (wrap(&Self::print))         = X
    );
    // clang-format on
  }

 private:
  void print(Connected& state) { std::cout << address << ':' << state.id << '\n'; };

  std::string address{};  /// shared data between states
};

}  // namespace

printf_logger logger;

int main() {
  data d{std::string{"127.0.0.1"}};
  sml::sm<data, sml::logger<printf_logger>> sm{d, Connected{1}, logger};
  sm.process_event(connect{1024});
  sm.process_event(interrupt{});
  sm.process_event(connect{1025});
  sm.process_event(disconnect{});
  assert(sm.is(sml::X));
}

This prints:

[{anonymous}::data][event] boost::ext::sml::v1_1_6::back::on_entry<boost::ext::sml::v1_1_6::back::_, boost::ext::sml::v1_1_6::back::initial>
[{anonymous}::data][event] {anonymous}::connect
[{anonymous}::data][transition] {anonymous}::Disconnected -> {anonymous}::Connected
[{anonymous}::data][action] {anonymous}::data::operator()()::<lambda(const auto:14&, {anonymous}::Connected&)>({anonymous}::connect)
[{anonymous}::data][action] zero_wrapper<void ({anonymous}::data::*)({anonymous}::Connected&), void ({anonymous}::data::*)({anonymous}::Connected&)>({anonymous}::connect)
127.0.0.1:1024
[{anonymous}::data][event] {anonymous}::interrupt
[{anonymous}::data][transition] {anonymous}::Connected -> {anonymous}::Interrupted
[{anonymous}::data][action] {anonymous}::data::operator()()::<lambda({anonymous}::Connected&, {anonymous}::Interrupted&)>({anonymous}::interrupt)
[{anonymous}::data][action] zero_wrapper<void ({anonymous}::data::*)({anonymous}::Connected&), void ({anonymous}::data::*)({anonymous}::Connected&)>({anonymous}::interrupt)
127.0.0.1:1024
[{anonymous}::data][event] {anonymous}::connect
[{anonymous}::data][transition] {anonymous}::Interrupted -> {anonymous}::Connected
[{anonymous}::data][action] {anonymous}::data::operator()()::<lambda(const auto:14&, {anonymous}::Connected&)>({anonymous}::connect)
[{anonymous}::data][action] zero_wrapper<void ({anonymous}::data::*)({anonymous}::Connected&), void ({anonymous}::data::*)({anonymous}::Connected&)>({anonymous}::connect)
127.0.0.1:1025
[{anonymous}::data][event] {anonymous}::disconnect
[{anonymous}::data][transition] {anonymous}::Connected -> terminate
[{anonymous}::data][action] zero_wrapper<void ({anonymous}::data::*)({anonymous}::Connected&), void ({anonymous}::data::*)({anonymous}::Connected&)>({anonymous}::disconnect)
127.0.0.1:1025

[rhaschke]

Great. Thanks!