state_machine_base.hpp

Go to the documentation of this file.

//                                                                                                  //
// This file is part of the Seadex yasmine ecosystem (http://yasmine.seadex.de).                    //
// Copyright (C) 2016-2017 Seadex GmbH                                                              //
//                                                                                                  //
// Licensing information is available in the folder "license" which is part of this distribution.   //
// The same information is available on the www @ http://yasmine.seadex.de/Licenses.html.           //
//                                                                                                  //


#ifndef STATE_MACHINE_BASE_484EA235_EEDE_4C19_9C46_C0687D950A13
#define STATE_MACHINE_BASE_484EA235_EEDE_4C19_9C46_C0687D950A13


#include "essentials/compatibility/thread.hpp"

#include "state_machine_introspection.hpp"
#include "event_collector.hpp"
#include "interruptible.hpp"
#include "transition_kind.hpp"
#include "constraint_fwd.hpp"
#include "behavior_fwd.hpp"
#include "transition_fwd.hpp"
#include "composite_state_fwd.hpp"
#include "region_fwd.hpp"
#include "event_id.hpp"
#include "state_machine_defect_fwd.hpp"


namespace sxy
{


 class vertex;
 class async_event_handler;
 class event_processing_callback;
 class uri;
 class region;


 class state_machine_base :
  private state_machine_introspection, public event_collector, private interruptible
 {
 public:
  explicit state_machine_base( const std::string& _name,
   event_processing_callback* const _event_processing_callback = SX_NULLPTR );
  virtual ~state_machine_base() SX_NOEXCEPT SX_OVERRIDE;
  SX_NO_COPY( state_machine_base )

   
   composite_state& get_root_state() const;

#ifdef Y_PROFILER
  sxe::uint32_t get_number_of_processed_events() const;
#endif

  virtual transition& add_transition( transition_uptr _transition );

  virtual transition& add_transition( const event_id _event_id, vertex& _source, vertex& _target,
   const sxy::transition_kind _kind = transition_kind::EXTERNAL,
   const constraint_function& _guard = constraint_function(),
   const behavior_function& _behavior = behavior_function() );

  virtual transition& add_transition( const event_ids& _event_ids, vertex& _source, vertex& _target,
   const sxy::transition_kind _kind = transition_kind::EXTERNAL,
   const constraint_function& _guard = constraint_function(),
   const behavior_function& _behavior = behavior_function() );

  virtual transition& add_transition( const event_id _event_id, vertex& _source, vertex& _target,
   const constraint_function& _guard, const sxy::transition_kind _kind = transition_kind::EXTERNAL );

  virtual transition& add_transition( const event_ids& _event_ids, vertex& _source, vertex& _target,
   const constraint_function& _guard, const sxy::transition_kind _kind = transition_kind::EXTERNAL );

  virtual transition& add_transition( const event_id _event_id, vertex& _source, vertex& _target,
   const constraint_function& _guard, const behavior_function& _behavior,
   const sxy::transition_kind _kind = transition_kind::EXTERNAL );

  virtual transition& add_transition( const event_ids& _event_ids, vertex& _source, vertex& _target,
   const constraint_function& _guard, const behavior_function& _behavior,
   const sxy::transition_kind _kind = transition_kind::EXTERNAL );

  virtual transition& add_transition( const event_id _event_id, vertex& _source, vertex& _target,
   const behavior_function& _behavior, const sxy::transition_kind _kind = transition_kind::EXTERNAL );

  virtual transition& add_transition( const event_ids& _event_ids, vertex& _source, vertex& _target,
   const behavior_function& _behavior, const sxy::transition_kind _kind = transition_kind::EXTERNAL );
  virtual bool fire_event( const event_sptr& _event ) = 0;

  bool check( state_machine_defects& _defects ) const;

  virtual bool run() = 0;

  virtual void halt();

  virtual void interrupt();

  virtual bool is_interrupted() const SX_OVERRIDE;

  virtual void set_behavior_of_unhandled_event_handler( const behavior_function& _behavior );

  virtual std::string get_name() const;


 protected:
  bool run( async_event_handler* const _async_event_handler );
  bool process_event( const event_sptr& _event, async_event_handler* const _async_event_handler );
  static void stop_all_async_states( state& _state );


 private:
  virtual const events& get_deferred_events() const SX_OVERRIDE;
  virtual raw_const_states get_active_state_configuration() const SX_OVERRIDE;
  void get_active_states_from_region( raw_const_states& _active_state_configuration, const region& _region ) const;
  void check_regions_for_active_states( raw_const_states& _active_state_configuration, const state& _state ) const;
  void add_deferred_event( const event_sptr& _event_id );
  bool process_deferred_events( async_event_handler* const _async_event_handler );
  static void stop_all_async_states_from_region( region_uptr& _region );
  virtual void interrupt_impl();
  void handle_unhandled_event( const event_sptr& _event );

  const std::string name_;
  event_processing_callback* event_processing_callback_;
  composite_state_uptr root_state_;
  transitions transitions_;
  events deferred_events_;
  sxe::atomic<bool> state_machine_is_running_;
  sxe::atomic<bool> interrupt_;
#ifdef Y_PROFILER
  sxe::uint32_t processed_events_;
#endif
  behavior_uptr event_handler_behavior_;

 };


}


#endif