msm.cpp

Go to the documentation of this file.

/******************************************************************************
** Copyright © 2015 by J.M.McGuiness, coder@hussar.me.uk
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
 
#include "stdafx.h"
 
#define BOOST_TEST_MODULE libjmmcg_tests
#include <boost/test/included/unit_test.hpp>
 
#include <boost/mpl/list.hpp>
 
#include "core/msm.hpp"
 
using namespace libjmmcg;
 
enum class states {
   start,
   middle,
   middle1,
   end,
   unknown
};
 
std::ostream &
operator<<(std::ostream &os, states const s) noexcept(false) {
   os<<static_cast<std::underlying_type<states>::type>(s);
   return os;
}
 
enum class end_states {
   start=10,
   middle,
   middle1,
   end,
   unknown
};
 
std::ostream &
operator<<(std::ostream &os, end_states const s) noexcept(false) {
   os<<static_cast<std::underlying_type<end_states>::type>(s);
   return os;
}
 
struct data {
   states state{states::unknown};
};
 
struct data_with_payload {
   end_states state{end_states::unknown};
   unsigned j{68};
};
 
using msm_types=boost::mpl::list<
   msm::unroll,
   msm::jump_table//,
// TODO  msm::computed_goto,
// TODO  msm::hash
>;
 
template<class MSMT>
struct noop_driver {
   struct fn_event {
      using argument_type=std::function<void()>;
 
      template<auto state, auto next>
      void operator()(argument_type &p) const noexcept(true) {
         p();
      }
      template<auto state, auto next, class Params>
      void operator()(Params &p) const noexcept(true) {
         p();
      }
   };
 
   struct state_machine_t final : MSMT::template state_transition_table<state_machine_t> {
      using base_t=typename MSMT::template state_transition_table<state_machine_t>;
      using row_t=typename MSMT::template row_types<states, states>;
      using transition_table=typename base_t::template rows<
         typename row_t::template row<states::start, fn_event, states::end>
      >;
   };
   using machine=typename MSMT::template machine<state_machine_t>;
 
   void process(states state) noexcept(false) {
      auto fn=std::bind(&state_machine_t::no_op::noop);
      msm.process(state, fn);
   }
 
   machine msm{};
};
 
template<class MSMT>
struct assign_driver_states {
   struct fn_event {
      using argument_type=data_with_payload;
 
      explicit fn_event(unsigned &j)
      : j_(j) {}
 
      template<auto state, end_states next>
      void operator()(argument_type &p) const noexcept(true) {
         p.state=next;
         p.j+=j_;
      }
      template<auto state, auto next, class Params>
      void operator()(Params &p) const noexcept(true) {
         p.state=next;
         p.j+=j_;
      }
 
   private:
      unsigned &j_;
   };
 
   struct state_machine_t final : MSMT::template state_transition_table<state_machine_t> {
      using base_t=typename MSMT::template state_transition_table<state_machine_t>;
      using row_t=typename MSMT::template row_types<states, end_states>;
      using transition_table=typename base_t::template rows<
         typename row_t::template row<states::start, fn_event, end_states::middle>,
         typename row_t::template row<states::middle, fn_event, end_states::middle1>,
         typename row_t::template row<states::middle1, fn_event, end_states::end>
      >;
   };
   using machine=typename MSMT::template machine<state_machine_t>;
 
   assign_driver_states()
   : j(42), msm(j, j, j) {
   }
 
   template<class Arg>
   void process(states state, Arg &p) noexcept(false) {
      msm.process(state, p);
   }
 
   unsigned j;
   machine msm;
};
 
template<class MSMT>
struct assign_driver {
   struct assign_event {
      using argument_type=data;
 
      template<auto state, states next>
      void operator()(argument_type &p) const noexcept(true) {
         p.state=next;
      }
      template<auto state, auto next, class Params>
      void operator()(Params &p) const noexcept(true) {
         p.state=next;
      }
   };
   struct is_true {
      template<auto state, auto next, class Params>
      bool operator()(Params &p) const noexcept(true) {
         return p.check;
      }
   };
 
   struct state_machine_t final : MSMT::template state_transition_table<state_machine_t> {
      using base_t=typename MSMT::template state_transition_table<state_machine_t>;
      using row_t=typename MSMT::template row_types<states, states>;
      using transition_table=typename base_t::template rows<
         typename row_t::template row<states::start, assign_event, states::middle>,
         typename row_t::template row<states::middle, assign_event, states::middle1>,
         typename row_t::template row<states::middle1, assign_event, states::end>
      >;
   };
   using machine=typename MSMT::template machine<state_machine_t>;
 
   template<class Arg>
   void process(states state, Arg &p) noexcept(false) {
      msm.process(state, p);
   }
 
   machine msm{};
};
 
BOOST_AUTO_TEST_SUITE(msm_tests)
 
BOOST_AUTO_TEST_CASE_TEMPLATE(noop_driver_ctor, msm_type, msm_types) {
   BOOST_CHECK_NO_THROW([[maybe_unused]] const noop_driver<msm_type> msm);
}
 
BOOST_AUTO_TEST_CASE_TEMPLATE(start_state_noop_driver, msm_type, msm_types) {
   noop_driver<msm_type> msm;
   BOOST_CHECK_NO_THROW(msm.process(states::start));
}
 
BOOST_AUTO_TEST_CASE_TEMPLATE(assign_driver_states_ctor, msm_type, msm_types) {
   BOOST_CHECK_NO_THROW([[maybe_unused]] const assign_driver_states<msm_type> msm);
}
 
BOOST_AUTO_TEST_CASE_TEMPLATE(start_state_assign_driver_states, msm_type, msm_types) {
   assign_driver_states<msm_type> msm;
   data_with_payload d;
   BOOST_CHECK_NO_THROW(msm.process(states::start, d));
   BOOST_CHECK_EQUAL(d.state, end_states::middle);
   BOOST_CHECK_EQUAL(d.j, 68+42);
   BOOST_CHECK_NO_THROW(msm.process(states::middle, d));
   BOOST_CHECK_EQUAL(d.state, end_states::middle1);
   BOOST_CHECK_EQUAL(d.j, 68+42+42);
}
 
BOOST_AUTO_TEST_CASE_TEMPLATE(assign_driver_ctor, msm_type, msm_types) {
   BOOST_CHECK_NO_THROW([[maybe_unused]] const assign_driver<msm_type> msm);
}
 
BOOST_AUTO_TEST_CASE_TEMPLATE(start_state_assign_event, msm_type, msm_types) {
   assign_driver<msm_type> msm;
   data d;
   BOOST_CHECK_NO_THROW(msm.process(states::start, d));
   BOOST_CHECK_EQUAL(d.state, states::middle);
   BOOST_CHECK_NO_THROW(msm.process(states::middle, d));
   BOOST_CHECK_EQUAL(d.state, states::middle1);
   BOOST_CHECK_NO_THROW(msm.process(states::middle1, d));
   BOOST_CHECK_EQUAL(d.state, states::end);
}
 
BOOST_AUTO_TEST_SUITE_END()