comparison DEPENDENCIES/generic/include/boost/msm/back/state_machine.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

     };
 
     template <class StateType,class Enable=int>
     struct deferred_msg_queue_helper 
     {
+        void clear(){}
     };
     template <class StateType>
     struct deferred_msg_queue_helper<StateType,
         typename ::boost::enable_if< 
             typename ::boost::msm::back::has_fsm_deferred_events<StateType>::type,int >::type> 
     {
     public:
         deferred_msg_queue_helper():m_deferred_events_queue(){}
+        void clear()
+        {
+            m_deferred_events_queue.clear();
+        }
         deferred_events_queue_t         m_deferred_events_queue;
     };
 
  public: 
     // tags

             m_forward = fct;
         }    
         exit_pt():m_forward(){}
         // by assignments, we keep our forwarding functor unchanged as our containing SM did not change
     template <class RHS>
-        exit_pt(RHS& rhs):m_forward(){}
+        exit_pt(RHS&):m_forward(){}
         exit_pt<ExitPoint>& operator= (const exit_pt<ExitPoint>& ) 
         { 
             return *this; 
         } 
     private:

 
         transition_fct f = ::boost::bind(pf,this,evt);
         m_events_queue.m_events_queue.push_back(f);
     }
     template <class EventType>
-    void enqueue_event_helper(EventType const& evt, ::boost::mpl::true_ const &)
+    void enqueue_event_helper(EventType const& , ::boost::mpl::true_ const &)
     {
         // no queue
     }
 
     void execute_queued_events_helper(::boost::mpl::false_ const &)
+    {
+        while(!m_events_queue.m_events_queue.empty())
+        {
+            transition_fct to_call = m_events_queue.m_events_queue.front();
+            m_events_queue.m_events_queue.pop_front();
+            to_call();
+        }
+    }
+    void execute_queued_events_helper(::boost::mpl::true_ const &)
+    {
+        // no queue required
+    }
+    void execute_single_queued_event_helper(::boost::mpl::false_ const &)
     {
         transition_fct to_call = m_events_queue.m_events_queue.front();
         m_events_queue.m_events_queue.pop_front();
         to_call();
     }
-    void execute_queued_events_helper(::boost::mpl::true_ const &)
+    void execute_single_queued_event_helper(::boost::mpl::true_ const &)
     {
         // no queue required
     }
-
     // enqueues an event in the message queue
     // call execute_queued_events to process all queued events.
     // Be careful if you do this during event processing, the event will be processed immediately
     // and not kept in the queue
     template <class EventType>

     // empty the queue and process events
     void execute_queued_events()
     {
         execute_queued_events_helper(typename is_no_message_queue<library_sm>::type());
     }
-
+    void execute_single_queued_event()
+    {
+        execute_single_queued_event_helper(typename is_no_message_queue<library_sm>::type());
+    }
     typename events_queue_t::size_type get_message_queue_size() const
     {
         return m_events_queue.m_events_queue.size();
     }
 

     }
 
     const events_queue_t& get_message_queue() const
     {
         return m_events_queue.m_events_queue;
+    }
+
+    void clear_deferred_queue()
+    {
+        m_deferred_events_queue.clear();
     }
 
     deferred_events_queue_t& get_deferred_queue()
     {
         return m_deferred_events_queue.m_deferred_events_queue;

                 typename has_do_serialize<T>::type,
                 typename is_composite_state<T>::type
             >::type
             ,void 
         >::type
-        operator()(T& t) const
+        operator()(T&) const
         {
             // no state to serialize
         }
         Archive& ar_;
     };

         // no terminate/interrupt states detected
         return false;
     }
     // the following functions handle pre/post-process handling  of a message queue
     template <class StateType,class EventType>
-    bool do_pre_msg_queue_helper(EventType const& evt, ::boost::mpl::true_ const &)
+    bool do_pre_msg_queue_helper(EventType const&, ::boost::mpl::true_ const &)
     {
         // no message queue needed
         return true;
     }
     template <class StateType,class EventType>

         {
             // give a chance to the concrete state machine to handle
             this->exception_caught(evt,*this,e);
         }
         BOOST_CATCH_END
-        return HANDLED_FALSE;
+        return HANDLED_TRUE;
     }
     // handling of deferred events
     // if none is found in the SM, take the following empty main version
     template <class StateType, class Enable = int> 
     struct handle_defer_helper

         m_event_processing = true;
         // if the event is generating a direct entry/fork, set the current state(s) to the direct state(s)
         direct_event_start_helper(this)(incomingEvent,fsm);
         // handle messages which were generated and blocked in the init calls
         m_event_processing = false;
+        // look for deferred events waiting
+        handle_defer_helper<library_sm> defer_helper(m_deferred_events_queue);
+        defer_helper.do_post_handle_deferred(HANDLED_TRUE);
         process_message_queue(this);
      }
      template <class Event,class FsmType>
      void do_exit(Event const& incomingEvent,FsmType& fsm)
      {

         region_entry_exit_helper< ::boost::mpl::int_<0> >::do_exit(this,incomingEvent);
         // then call our own exit
         (static_cast<Derived*>(this))->on_exit(incomingEvent,fsm);
         // give the history a chance to handle this (or not).
         m_history.history_exit(this->m_states);
+        // history decides what happens with deferred events
+        if (!m_history.process_deferred_events(incomingEvent))
+        {
+            clear_deferred_queue();
+        }
      }
 
     // the IBM and VC<8 compilers seem to have problems with the friend declaration of dispatch_table
 #if defined (__IBMCPP__) || (defined(_MSC_VER) && (_MSC_VER < 1400))
      public: