src/StateMachine.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2005-2011 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2004-2011 Marcelo Roberto Jimenez ( phoenix@amule.org )
   6 //
   7 // Any parts of this program derived from the xMule, lMule or eMule project,
   8 // or contributed by third-party developers are copyrighted by their
   9 // respective authors.
  10 //
  11 // This program is free software; you can redistribute it and/or modify
  12 // it under the terms of the GNU General Public License as published by
  13 // the Free Software Foundation; either version 2 of the License, or
  14 // (at your option) any later version.
  15 //
  16 // This program is distributed in the hope that it will be useful,
  17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 // GNU General Public License for more details.
  20 //
  21 // You should have received a copy of the GNU General Public License
  22 // along with this program; if not, write to the Free Software
  23 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  24 //
  25
  26 #include "StateMachine.h"
  27
  28 #include <common/StringFunctions.h>
  29
  30 CStateMachine::CStateMachine(
  31                 const wxString &name,
  32                 const unsigned int maxStates,
  33                 const t_sm_state initialState )
  34 :
  35 m_stateMutex(wxMUTEX_RECURSIVE),
  36 m_queueMutex(wxMUTEX_RECURSIVE),
  37 m_name(name),
  38 m_maxStates(maxStates)
  39 {
  40         m_state = initialState;
  41         m_clockCounter = 0;
  42         m_clocksInCurrentState = 0;
  43 }
  44
  45 CStateMachine::~CStateMachine()
  46 {
  47 }
  48
  49 void CStateMachine::Clock()
  50 {
  51         t_sm_state old_state;
  52         t_sm_event event;
  53         bool state_entry;
  54
  55         old_state = m_state;
  56
  57         /* Process state change acording to event */
  58         if (!m_queue.empty()) {
  59                 event = m_queue.front();
  60                 m_queue.pop();
  61         } else {
  62                 event = 0;
  63         }
  64
  65         /* State changes can only happen here */
  66         wxMutexLocker lock(m_stateMutex);
  67         m_state = next_state( event );
  68
  69 //#if 0
  70         /* Debug */
  71         ++m_clockCounter;
  72         state_entry = ( m_state != old_state ) || ( m_clockCounter == 1 );
  73         if( state_entry )
  74         {
  75                 m_clocksInCurrentState = 0;
  76                 printf( "%s(%04d): %d -> %d\n",
  77                         (const char *)unicode2char(m_name),
  78                         m_clockCounter, old_state, m_state);
  79         }
  80         ++m_clocksInCurrentState;
  81 //#endif
  82
  83         /* Process new state entry */
  84         if( m_state < m_maxStates )
  85         {
  86                 /* It should be ok to call Clock() recursively inside this
  87                  * procedure because state change has already happened. Also
  88                  * the m_state mutex is recursive. */
  89                 process_state(m_state, state_entry);
  90         }
  91 }
  92
  93 /* In multithreaded implementations, this must be locked */
  94 void CStateMachine::Schedule(t_sm_event event)
  95 {
  96         wxMutexLocker lock(m_queueMutex);
  97         m_queue.push(event);
  98 }
  99
 100 void CStateMachine::flush_queue()
 101 {
 102         while (!m_queue.empty()) {
 103                 m_queue.pop();
 104         }
 105 }
 106 // File_checked_for_headers